diff --git a/.changeset/ten-wolves-reflect.md b/.changeset/ten-wolves-reflect.md
new file mode 100644
index 000000000..e8501f45e
--- /dev/null
+++ b/.changeset/ten-wolves-reflect.md
@@ -0,0 +1,13 @@
+---
+'@getodk/xforms-engine': minor
+---
+
+**BREAKING CHANGE**
+
+The main engine entrypoint (formerly `initializeForm`) has been split into:
+
+- `loadForm`, producing an intermediate result from which many instances of the same form can be created (with a `createInstance` method on that result)
+
+- `createInstance`, a convenience wrapper composing the result from `loadForm` and its `createInstance` method to create a single instance; this entrypoint effectively restores the behavior of `initializeForm`
+
+Some interfaces related to the former `initializeForm` have also been refined to reflect this change.
diff --git a/packages/scenario/src/client/init.ts b/packages/scenario/src/client/init.ts
index 95070bf24..214eaebc0 100644
--- a/packages/scenario/src/client/init.ts
+++ b/packages/scenario/src/client/init.ts
@@ -1,12 +1,12 @@
 import type { JRResourceService } from '@getodk/common/jr-resources/JRResourceService.ts';
 import type { XFormsElement } from '@getodk/common/test/fixtures/xform-dsl/XFormsElement.ts';
 import type {
-	EngineConfig,
 	FormResource,
+	LoadFormOptions,
 	OpaqueReactiveObjectFactory,
 	RootNode,
 } from '@getodk/xforms-engine';
-import { initializeForm } from '@getodk/xforms-engine';
+import { createInstance } from '@getodk/xforms-engine';
 import type { Owner } from 'solid-js';
 import { createRoot, getOwner, runWithOwner } from 'solid-js';
 import type { MissingResourceBehavior } from '../../../xforms-engine/dist/client/constants';
@@ -62,7 +62,7 @@ export interface InitializeTestFormOptions {
 
 const defaultConfig = {
 	fetchFormDefinition: fetchFormDefinitionStub,
-} as const satisfies Omit<EngineConfig, 'stateFactory'>;
+} as const satisfies LoadFormOptions;
 
 interface InitializedTestForm {
 	readonly instanceRoot: RootNode;
@@ -82,19 +82,21 @@ export const initializeTestForm = async (
 		}
 
 		const formResource = await getFormResource(testForm);
-		const instanceRoot = await runWithOwner(owner, async () => {
-			return initializeForm(formResource, {
-				config: {
+		const instance = await runWithOwner(owner, async () => {
+			return createInstance(formResource, {
+				form: {
 					...defaultConfig,
 					fetchFormAttachment: options.resourceService.handleRequest,
 					missingResourceBehavior: options.missingResourceBehavior,
+				},
+				instance: {
 					stateFactory: options.stateFactory,
 				},
 			});
 		})!;
 
 		return {
-			instanceRoot,
+			instanceRoot: instance.root,
 			owner,
 			dispose,
 		};
diff --git a/packages/scenario/test/serialization.test.ts b/packages/scenario/test/serialization.test.ts
index c4e5536d0..5fdefe4cf 100644
--- a/packages/scenario/test/serialization.test.ts
+++ b/packages/scenario/test/serialization.test.ts
@@ -9,7 +9,7 @@ import {
 	t,
 	title,
 } from '@getodk/common/test/fixtures/xform-dsl/index.ts';
-import type { EngineConfig, InitializeFormOptions } from '@getodk/xforms-engine';
+import type { LoadFormOptions } from '@getodk/xforms-engine';
 import { describe, expect, it } from 'vitest';
 import { stringAnswer } from '../src/answer/ExpectedStringAnswer.ts';
 import { Scenario } from '../src/jr/Scenario.ts';
@@ -175,8 +175,7 @@ describe('ExternalSecondaryInstanceParseTest.java', () => {
 		 * - Insofar as we may find ourselves implementing similar logic (albeit
 		 *   serving other purposes), how can we establish a clear interface
 		 *   contract around behaviors like this? Should it be more consistent? Does
-		 *   our current {@link EngineConfig.fetchFormDefinition}
-		 *   option—configurable in {@link InitializeFormOptions}—provide enough
+		 *   our current {@link LoadFormOptions.fetchFormDefinition} provide enough
 		 *   informational surface area to communicate such intent (and allow both
 		 *   clients and engine alike to have clarity of that intent at
 		 *   call/handling sites)?
diff --git a/packages/web-forms/src/components/OdkWebForm.vue b/packages/web-forms/src/components/OdkWebForm.vue
index feed0376a..59b3d457d 100644
--- a/packages/web-forms/src/components/OdkWebForm.vue
+++ b/packages/web-forms/src/components/OdkWebForm.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
 import type {
 	ChunkedInstancePayload,
+	FetchFormAttachment,
 	MissingResourceBehavior,
 	MonolithicInstancePayload,
+	RootNode,
 } from '@getodk/xforms-engine';
-import { initializeForm, type FetchFormAttachment, type RootNode } from '@getodk/xforms-engine';
+import { loadForm } from '@getodk/xforms-engine';
 import Button from 'primevue/button';
 import Card from 'primevue/card';
 import PrimeMessage from 'primevue/message';
@@ -107,20 +109,31 @@ const odkForm = ref<RootNode>();
 const submitPressed = ref(false);
 const initializeFormError = ref<FormInitializationError | null>();
 
-initializeForm(props.formXml, {
-	config: {
-		fetchFormAttachment: props.fetchFormAttachment,
-		missingResourceBehavior: props.missingResourceBehavior,
-		stateFactory: reactive,
-	},
-})
-	.then((f) => {
-		odkForm.value = f;
-	})
-	.catch((cause) => {
-		initializeFormError.value = new FormInitializationError(cause);
+const init = async () => {
+	const { formXml, fetchFormAttachment, missingResourceBehavior } = props;
+
+	const formResult = await loadForm(formXml, {
+		fetchFormAttachment,
+		missingResourceBehavior,
 	});
 
+	if (formResult.status === 'failure') {
+		initializeFormError.value = FormInitializationError.fromError(formResult.error);
+
+		return;
+	}
+
+	try {
+		const { root } = formResult.createInstance({ stateFactory: reactive });
+
+		odkForm.value = root;
+	} catch (error) {
+		initializeFormError.value = FormInitializationError.from(error);
+	}
+};
+
+void init();
+
 const handleSubmit = () => {
 	const root = odkForm.value;
 
diff --git a/packages/web-forms/src/lib/error/FormInitializationError.ts b/packages/web-forms/src/lib/error/FormInitializationError.ts
index ca9d750de..5b133a8ca 100644
--- a/packages/web-forms/src/lib/error/FormInitializationError.ts
+++ b/packages/web-forms/src/lib/error/FormInitializationError.ts
@@ -2,13 +2,15 @@ import {
 	isUnknownObject,
 	type UnknownObject,
 } from '@getodk/common/lib/runtime-types/shared-type-predicates.ts';
-import type { initializeForm } from '@getodk/xforms-engine';
+import type { createInstance } from '@getodk/xforms-engine';
 
-interface ErrorLikeCause extends UnknownObject {
+interface ErrorLike {
 	readonly message: string;
 	readonly stack?: string | null;
 }
 
+interface ErrorLikeCause extends ErrorLike, UnknownObject {}
+
 const isErrorLikeCause = (cause: unknown): cause is ErrorLikeCause => {
 	if (!isUnknownObject(cause)) {
 		return false;
@@ -24,6 +26,13 @@ const isErrorLikeCause = (cause: unknown): cause is ErrorLikeCause => {
  */
 const UNKNOWN_ERROR_MESSAGE = 'Unknown error';
 
+interface FormInitializationErrorOptions {
+	readonly message: string;
+	readonly cause?: unknown;
+	readonly unknownCauseDetail?: string | null;
+	readonly stack?: string | null;
+}
+
 /**
  * Provides a minimal, uniform representation of most general, known form load
  * failure conditions.
@@ -37,7 +46,7 @@ const UNKNOWN_ERROR_MESSAGE = 'Unknown error';
  * coming refinement.
  *
  * We handle these broad cases, each of which may be produced by a rejected
- * {@link Promise}, as returned by {@link initializeForm}:
+ * {@link Promise}, as returned by {@link createInstance}:
  *
  * 1. Promise is rejected with any {@link Error}, or subclass/inheritor thereof,
  *    as thrown by `@getodk/xforms-engine` or `@getodk/xpath`. These are
@@ -63,7 +72,7 @@ const UNKNOWN_ERROR_MESSAGE = 'Unknown error';
  *    system. We will likely make some meaningful effort on this front as well,
  *    but we accept it will never be exhaustive. Most importantly, we cannot
  *    truly know what types may be thrown (and then passed through as a
- *    {@link Promise} rejection by {@link initializeForm}).
+ *    {@link Promise} rejection by {@link createInstance}).
  *
  * As such where the type of {@link cause} is...
  *
@@ -86,32 +95,51 @@ const UNKNOWN_ERROR_MESSAGE = 'Unknown error';
  * to `@getodk/xforms-engine`.
  */
 export class FormInitializationError extends Error {
-	readonly unknownCauseDetail: string | null;
-	readonly stack?: string | undefined;
-
-	constructor(readonly cause: unknown) {
-		let message: string;
-		let unknownCauseDetail: string | null = null;
-		let stack: string | null = null;
+	static fromError(cause: ErrorLike): FormInitializationError {
+		return new this(cause);
+	}
 
-		// If `initializeForm` rejected with an error, we can derive its message and stack
+	static from(cause: unknown): FormInitializationError {
 		if (cause instanceof Error || isErrorLikeCause(cause)) {
-			message = cause.message;
-			stack = cause.stack ?? null;
-		} else if (isUnknownObject(cause) && typeof cause.message === 'string') {
-			message = cause.message;
-		} else if (typeof cause === 'string') {
-			message = cause;
-		} else {
-			message = 'Unknown error';
+			return this.fromError(cause);
+		}
 
-			try {
-				unknownCauseDetail = JSON.stringify(cause, null, 2);
-			} catch {
-				// Ignore JSON serialization error
-			}
+		if (isUnknownObject(cause) && typeof cause.message === 'string') {
+			return new this({
+				message: cause.message,
+				cause,
+			});
 		}
 
+		if (typeof cause === 'string') {
+			return new this({
+				message: cause,
+				cause,
+			});
+		}
+
+		let unknownCauseDetail: string | null = null;
+
+		try {
+			unknownCauseDetail = JSON.stringify(cause, null, 2);
+		} catch {
+			// Ignore JSON serialization error
+		}
+
+		return new this({
+			message: 'Unknown error',
+			cause,
+			unknownCauseDetail,
+		});
+	}
+
+	readonly cause: unknown;
+	readonly unknownCauseDetail: string | null;
+	readonly stack?: string | undefined;
+
+	private constructor(options: FormInitializationErrorOptions) {
+		let message = options.message;
+
 		// TODO: this occurs when Solid's production build detects a "potential
 		// infinite loop" (i.e. either a form cycle, or potentially a serious bug in
 		// the engine!).
@@ -119,9 +147,12 @@ export class FormInitializationError extends Error {
 			message = 'Unknown error';
 		}
 
+		const { cause, unknownCauseDetail, stack } = options;
+
 		super(message, { cause });
 
-		this.unknownCauseDetail = unknownCauseDetail;
+		this.cause = cause;
+		this.unknownCauseDetail = unknownCauseDetail ?? null;
 
 		if (stack != null) {
 			this.stack = stack;
diff --git a/packages/web-forms/tests/helpers.ts b/packages/web-forms/tests/helpers.ts
index 5e12a838f..e6667ae9f 100644
--- a/packages/web-forms/tests/helpers.ts
+++ b/packages/web-forms/tests/helpers.ts
@@ -1,7 +1,7 @@
 import { xformFixturesByIdentifier } from '@getodk/common/fixtures/xforms.ts';
 import type { AnyFunction } from '@getodk/common/types/helpers.d.ts';
 import type { AnyControlNode, RootNode } from '@getodk/xforms-engine';
-import { initializeForm } from '@getodk/xforms-engine';
+import { createInstance } from '@getodk/xforms-engine';
 import type { MountingOptions } from '@vue/test-utils';
 import PrimeVue from 'primevue/config';
 import type { MockInstance } from 'vitest';
@@ -45,12 +45,13 @@ export const getFormXml = (fileName: string): Promise<string> => {
 
 export const getReactiveForm = async (formPath: string): Promise<RootNode> => {
 	const formXml = await getFormXml(formPath);
-
-	return await initializeForm(formXml, {
-		config: {
+	const instance = await createInstance(formXml, {
+		instance: {
 			stateFactory: reactive,
 		},
 	});
+
+	return instance.root;
 };
 
 type GlobalMountOptions = Required<MountingOptions<unknown>>['global'];
diff --git a/packages/xforms-engine/src/client/EngineConfig.ts b/packages/xforms-engine/src/client/EngineConfig.ts
deleted file mode 100644
index 81e6e3d46..000000000
--- a/packages/xforms-engine/src/client/EngineConfig.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import type { initializeForm } from '../instance/index.ts';
-import type { MissingResourceBehavior, MissingResourceBehaviorDefault } from './constants.ts';
-import type { OpaqueReactiveObjectFactory } from './OpaqueReactiveObjectFactory.ts';
-import type { FetchFormAttachment, FetchResource } from './resources.ts';
-
-/**
- * Options provided by a client to specify certain aspects of engine runtime
- * behavior. These options will generally be intended to facilitate cooperation
- * where there is mixed responsibility between a client and the engine, or where
- * the engine may provide sensible defaults which a client could be expected to
- * override or augment.
- */
-export interface EngineConfig {
-	/**
-	 * A client may specify a generic function for constructing stateful objects.
-	 * The only hard requirement of this function is that it accepts an **object**
-	 * and returns an object of the same shape. The engine will use this function
-	 * to initialize client-facing state, and will mutate properties of the object
-	 * when their corresponding state is changed.
-	 *
-	 * A client may use this function to provide its own implementation of
-	 * reactivity with semantics like those described above. The mechanism of
-	 * reactivity, if any, is at the discretion of the client. It is expected
-	 * that clients providing this function will use a reactive subscribe-on-read
-	 * mechanism to handle state updates conveyed by the engine.
-	 */
-	readonly stateFactory?: OpaqueReactiveObjectFactory;
-
-	/**
-	 *
-	 * A client may specify an arbitrary {@link fetch}-like function for retrieving an XML XForm form
-	 * definition.
-	 *
-	 * Notes:
-	 *
-	 * - This configuration will only be consuled for calls to
-	 *   {@link initializeForm} with a URL referencing an XML XForm definition. It
-	 *   will be ignored for calls passing an XML XForm form definition directly.
-	 *
-	 * - For calls to {@link initializeForm} with a URL, if this configuration is
-	 *   not specified it will default to the global {@link fetch} function (if
-	 *   one is defined).
-	 */
-	readonly fetchFormDefinition?: FetchResource;
-
-	/**
-	 * A client may specify an arbitrary {@link fetch}-like function to retrieve a
-	 * form's attachments, i.e. any `jr:` URL referenced by the form (as specified
-	 * by {@link https://getodk.github.io/xforms-spec/ | ODK XForms}).
-	 *
-	 * Notes:
-	 *
-	 * - This configuration will be consulted for all supported form attachments,
-	 *   as a part of {@link initializeForm | form initialization}.
-	 *
-	 * - If this configuration is not specified it will default to the global
-	 *   {@link fetch} function (if one is defined).
-	 *
-	 * This default behavior will typically result in failure to load form
-	 * attachments—and in most cases this will also cause
-	 * {@link initializeForm | form initialization} to fail overall—with the
-	 * following exceptions:
-	 *
-	 * - **CLIENT-SPECIFIC:** Usage in coordination with a client-implemented
-	 *   {@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API | Serivce Worker},
-	 *   which can intercept network requests **generally**. Clients already using
-	 *   a Service Worker may opt for the convenience of handling network requests
-	 *   for `jr:` URLs along with any other network interception logic. Client
-	 *   implementors should be warned, however, that such `jr:` URLs are not
-	 *   namespaced or otherwise scoped to a particular form; such a client would
-	 *   therefore inherently need to coordinate state between the Service Worker
-	 *   and the main thread (or whatever other realm calls
-	 *   {@link initializeForm}).
-	 */
-	readonly fetchFormAttachment?: FetchFormAttachment;
-
-	/**
-	 * @see {@link MissingResourceBehavior}
-	 * @see {@link MissingResourceBehaviorDefault}
-	 *
-	 * @default MissingResourceBehaviorDefault
-	 */
-	readonly missingResourceBehavior?: MissingResourceBehavior;
-}
diff --git a/packages/xforms-engine/src/client/constants.ts b/packages/xforms-engine/src/client/constants.ts
index c21ca8b13..d3a264bf5 100644
--- a/packages/xforms-engine/src/client/constants.ts
+++ b/packages/xforms-engine/src/client/constants.ts
@@ -1,21 +1,19 @@
-import type { PrimaryInstance } from '../instance/PrimaryInstance.ts';
-import type { InitializeForm } from './index.ts';
+import type { LoadForm } from './form/LoadForm.ts';
 import type { ValidationTextRole } from './TextRange.ts';
 
 export const MISSING_RESOURCE_BEHAVIOR = {
 	/**
-	 * When this behavior is configured, {@link InitializeForm | initializing} a
-	 * {@link PrimaryInstance} for a form which references any **missing**
-	 * resources will fail, producing an error to the calling client.
+	 * When this behavior is configured, {@link LoadForm | loading a form} which
+	 * references any **missing** resources will fail, producing an error to the
+	 * calling client.
 	 *
 	 * @see {@link MissingResourceBehavior}
 	 */
 	ERROR: 'ERROR',
 
 	/**
-	 * When this behavior is configured, {@link InitializeForm | initializing} a
-	 * {@link PrimaryInstance} for a form which references any **missing**
-	 * resources will succeed (producing a warning).
+	 * When this behavior is configured, {@link LoadForm | loading a form} which
+	 * references any **missing** resources will succeed (producing a warning).
 	 *
 	 * Such missing resources will be parsed as if they are blank, as appropriate
 	 * for the resource's XForm semantic usage and/or format.
@@ -39,8 +37,8 @@ export type MissingResourceBehaviorBlank = typeof MISSING_RESOURCE_BEHAVIOR.BLAN
 export type MissingResourceBehaviorDefault = typeof MISSING_RESOURCE_BEHAVIOR.DEFAULT;
 
 /**
- * Specifies behavior for {@link InitializeForm | initializing} a form's
- * {@link PrimaryInstance} which references any **missing** resources.
+ * Specifies behavior for {@link LoadForm | loading a form} which references any
+ * **missing** resources.
  *
  * Here the term "missing" is consistent with
  * {@link https://www.rfc-editor.org/rfc/rfc9110#status.404 | HTTP 404 status}
diff --git a/packages/xforms-engine/src/client/form/CreateFormInstance.ts b/packages/xforms-engine/src/client/form/CreateFormInstance.ts
new file mode 100644
index 000000000..6ce7ca36d
--- /dev/null
+++ b/packages/xforms-engine/src/client/form/CreateFormInstance.ts
@@ -0,0 +1,19 @@
+import type { RootNode } from '../RootNode.ts';
+import type { FormInstance, FormInstanceCreateMode } from './FormInstance.ts';
+import type { FormInstanceConfig } from './FormInstanceConfig.ts';
+import type { LoadForm } from './LoadForm.ts';
+import type { LoadFormResult } from './LoadFormResult.ts';
+
+export type CreatedFormInstance = FormInstance<FormInstanceCreateMode>;
+
+/**
+ * @todo This is fallible! Client-facing interfaces will need to account for
+ * this. We've begun addressing fallibility _at the interface level_ in
+ * {@link LoadForm} (with {@link LoadFormResult}). We'll eventually have a more
+ * general interface pattern for this, and we'll apply it here as well. The baby
+ * step approach in {@link LoadFormResult} is impractical here due to
+ * engine-internal designs, and revising that is currently out of scope. As
+ * such, explicit interface-level documentation of fallibility is deferred here,
+ * on {@link RootNode} itself, and into any of its sub-interfaces.
+ */
+export type CreateFormInstance = (config?: FormInstanceConfig) => CreatedFormInstance;
diff --git a/packages/xforms-engine/src/client/form/FormInstance.ts b/packages/xforms-engine/src/client/form/FormInstance.ts
new file mode 100644
index 000000000..b76c415a6
--- /dev/null
+++ b/packages/xforms-engine/src/client/form/FormInstance.ts
@@ -0,0 +1,36 @@
+import type { RootNode } from '../RootNode.ts';
+import type { InstantiableLoadFormResult, LoadFormResult } from './LoadFormResult.ts';
+
+/**
+ * Represents an instance which is newly created from a form definition.
+ *
+ * A newly created instance is populated with default values and state defined
+ * by the form.
+ *
+ * Computations are performed on initialization as specified by
+ * {@link https://getodk.github.io/xforms-spec/ | ODK XForms}, as the instance's
+ * {@link https://getodk.github.io/xforms-spec/#event:odk-instance-first-load | first load}.
+ */
+export type FormInstanceCreateMode = 'create';
+
+/**
+ * @todo Other modes incoming!
+ */
+// prettier-ignore
+export type FormInstanceInitializationMode =
+	| FormInstanceCreateMode;
+
+/**
+ * @todo this could hypothetically convey warnings and/or errors, just as
+ * {@link LoadFormResult} does. This has been deferred because:
+ *
+ * - We really want a more thoughtful design for Result types
+ * - The `try`/`catch` approach to capturing all errors takes a huge performance
+ *   hit, which we should not incur if we have a more thoughtful design coming
+ *   eventually. It would be too easy to forget about, indefinitely!
+ */
+export interface FormInstance<Mode extends FormInstanceInitializationMode> {
+	readonly formResult: InstantiableLoadFormResult;
+	readonly mode: Mode;
+	readonly root: RootNode;
+}
diff --git a/packages/xforms-engine/src/client/form/FormInstanceConfig.ts b/packages/xforms-engine/src/client/form/FormInstanceConfig.ts
new file mode 100644
index 000000000..b809bca89
--- /dev/null
+++ b/packages/xforms-engine/src/client/form/FormInstanceConfig.ts
@@ -0,0 +1,18 @@
+import type { OpaqueReactiveObjectFactory } from '../OpaqueReactiveObjectFactory.ts';
+
+export interface FormInstanceConfig {
+	/**
+	 * A client may specify a generic function for constructing stateful objects.
+	 * The only hard requirement of this function is that it accepts an **object**
+	 * and returns an object of the same shape. The engine will use this function
+	 * to initialize client-facing state, and will mutate properties of the object
+	 * when their corresponding state is changed.
+	 *
+	 * A client may use this function to provide its own implementation of
+	 * reactivity with semantics like those described above. The mechanism of
+	 * reactivity, if any, is at the discretion of the client. It is expected that
+	 * clients providing this function will use a reactive subscribe-on-read
+	 * mechanism to handle state updates conveyed by the engine.
+	 */
+	readonly stateFactory?: OpaqueReactiveObjectFactory;
+}
diff --git a/packages/xforms-engine/src/client/form/FormResource.ts b/packages/xforms-engine/src/client/form/FormResource.ts
new file mode 100644
index 000000000..27c802003
--- /dev/null
+++ b/packages/xforms-engine/src/client/form/FormResource.ts
@@ -0,0 +1 @@
+export type FormResource = Blob | File | URL | string;
diff --git a/packages/xforms-engine/src/client/form/LoadForm.ts b/packages/xforms-engine/src/client/form/LoadForm.ts
new file mode 100644
index 000000000..17cb1be6c
--- /dev/null
+++ b/packages/xforms-engine/src/client/form/LoadForm.ts
@@ -0,0 +1,92 @@
+import type { loadForm } from '../../entrypoints/loadForm.ts';
+import type { MissingResourceBehavior } from '../constants.ts';
+import type { FetchFormAttachment, FetchResource } from '../resources.ts';
+import type { FormResource } from './FormResource.ts';
+import type { LoadFormFailureResult, LoadFormResult } from './LoadFormResult.ts';
+
+/**
+ * @see {@link LoadForm}
+ */
+export interface FormLoadPromise<T> extends PromiseLike<T> {}
+
+/**
+ * Any fetch-like {@link LoadFormOptions | form loading options} which are not
+ * provided will default to the global {@link fetch} function, if one is
+ * available in the calling environment. If a global {@link fetch} function is
+ * _is not available_, and if the associated form loading option is required for
+ * the provided {@link FormResource} to be loaded, a
+ * {@link LoadFormFailureResult} will be produced.
+ */
+export type GlobalFetchDefault = typeof fetch;
+
+export interface LoadFormOptions {
+	/**
+	 * A client may specify an arbitrary {@link fetch}-like function for
+	 * retrieving an XML XForm form definition.
+	 *
+	 * Calls to {@link loadForm | load a form} from a form definition provided as
+	 * either a raw XML string or {@link Blob} data containing an XML string, this
+	 * option will be ignored.
+	 *
+	 * Calls to load a form by {@link URL} will consult this option, if defined.
+	 *
+	 * If this option is omitted, loading a form by URL will use the
+	 * {@link GlobalFetchDefault | global fetch function} by default.
+	 */
+	readonly fetchFormDefinition?: FetchResource;
+
+	/**
+	 * A client may specify an arbitrary {@link fetch}-like function to retrieve a
+	 * form's attachments, i.e. any `jr:` URL referenced by the form (as specified
+	 * by {@link https://getodk.github.io/xforms-spec/ | ODK XForms}).
+	 *
+	 * As part of {@link loadForm | loading a form}, once the form definition
+	 * itself is resolved, this option (if provided) will be consulted to load any
+	 * form attachments referenced by the form definition.
+	 *
+	 * If this option is omitted, the engine will attempt to load form attachments
+	 * by calling the {@link GlobalFetchDefault | global fetch function} with each
+	 * attachment's `jr:` URL. This default behavior will typically result in
+	 * failure to load form attachments—and in most cases this will in most cases
+	 * cause {@link loadForm | loading a form} to produce a
+	 * {@link LoadFormFailureResult}, with the following exception:
+	 *
+	 * Clients implementing a
+	 * {@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API | Service Worker}
+	 * (e.g. supporting offline functionality, or any other use case for
+	 * intercepting network requests) may opt for the convenience of handling
+	 * network requests _for form attachments' `jr:` URLs_ along with any other
+	 * network interception logic. Client implementors should be warned, however,
+	 * that such `jr:` URLs are not namespaced or otherwise scoped to a particular
+	 * form definition! Such a client would therefore inherently need to
+	 * coordinate state between the Service Worker and the main thread (or
+	 * whatever other realm calls {@link loadForm}).
+	 *
+	 * @todo We can almost certainly address the scoping caveat! We'll probably
+	 * want to design for that as part of offline support.
+	 */
+	// TODO (internal): Also note that the current round of revisions to
+	// engine/client entrypoints are not directly designed to address the above
+	// `@todo`, but the offline use case in particular is very much in mind for
+	// these interface changes!
+	readonly fetchFormAttachment?: FetchFormAttachment;
+
+	/**
+	 * @see {@link MissingResourceBehavior}
+	 * @see {@link MissingResourceBehaviorDefault}
+	 *
+	 * @default MissingResourceBehaviorDefault
+	 */
+	readonly missingResourceBehavior?: MissingResourceBehavior;
+}
+
+/**
+ * Note: loading a form produce a {@link Promise} which **will never reject**.
+ * Rather than rejecting, any errors encountered in the process of loading a
+ * form will be **resolved**, in a
+ * {@link LoadFormFailureResult.error | FormLoadFailureResult error}.
+ */
+export type LoadForm = (
+	formResource: FormResource,
+	options?: LoadFormOptions
+) => FormLoadPromise<LoadFormResult>;
diff --git a/packages/xforms-engine/src/client/form/LoadFormResult.ts b/packages/xforms-engine/src/client/form/LoadFormResult.ts
new file mode 100644
index 000000000..d015be49b
--- /dev/null
+++ b/packages/xforms-engine/src/client/form/LoadFormResult.ts
@@ -0,0 +1,76 @@
+import type { UnknownObject } from '@getodk/common/lib/type-assertions/assertUnknownObject.ts';
+import type { AnyFunction } from '@getodk/common/types/helpers.js';
+import type { LoadFormFailureError } from '../../error/LoadFormFailureError.ts';
+import type { CreateFormInstance } from './CreateFormInstance.ts';
+
+// Re-export for client access
+export type { LoadFormFailureError };
+
+// prettier-ignore
+export type FormResultStatus =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| 'success'
+	| 'warning'
+	| 'failure';
+
+/**
+ * @todo Pending design and modeling of warning cases.
+ */
+export type LoadFormWarnings = UnknownObject;
+
+// prettier-ignore
+type FailedLoadFormResultMethodParameters<T extends AnyFunction> =
+	& readonly never[]
+	& (
+			Parameters<T> extends { readonly length: infer Length extends number }
+				? { readonly length: Length }
+				: never
+		);
+
+export type FailedLoadFormResultMethod<T extends AnyFunction> = (
+	...args: FailedLoadFormResultMethodParameters<T>
+) => never;
+
+// prettier-ignore
+export type FallibleLoadFormResultMethod<T extends AnyFunction> =
+	// eslint-disable-next-line @typescript-eslint/sort-type-constituents
+	| T
+	| FailedLoadFormResultMethod<T>;
+
+interface BaseLoadFormResult {
+	readonly status: FormResultStatus;
+	readonly warnings: LoadFormWarnings | null;
+	readonly error: LoadFormFailureError | null;
+	readonly createInstance: FallibleLoadFormResultMethod<CreateFormInstance>;
+}
+
+export interface LoadFormSuccessResult extends BaseLoadFormResult {
+	readonly status: 'success';
+	readonly warnings: null;
+	readonly error: null;
+	readonly createInstance: CreateFormInstance;
+}
+
+export interface LoadFormWarningResult extends BaseLoadFormResult {
+	readonly status: 'warning';
+	readonly warnings: LoadFormWarnings;
+	readonly error: null;
+	readonly createInstance: CreateFormInstance;
+}
+
+export interface LoadFormFailureResult extends BaseLoadFormResult {
+	readonly status: 'failure';
+	readonly warnings: LoadFormWarnings | null;
+	readonly error: LoadFormFailureError;
+	readonly createInstance: FailedLoadFormResultMethod<CreateFormInstance>;
+}
+
+// prettier-ignore
+export type InstantiableLoadFormResult =
+	| LoadFormSuccessResult
+	| LoadFormWarningResult
+
+// prettier-ignore
+export type LoadFormResult =
+	| InstantiableLoadFormResult
+	| LoadFormFailureResult;
diff --git a/packages/xforms-engine/src/client/index.ts b/packages/xforms-engine/src/client/index.ts
index 2f5b5f5be..0ab09824f 100644
--- a/packages/xforms-engine/src/client/index.ts
+++ b/packages/xforms-engine/src/client/index.ts
@@ -1,29 +1,45 @@
-import type { EngineConfig } from './EngineConfig.ts';
-import type { RootNode } from './RootNode.ts';
-
-export type FormResource = Blob | URL | string;
-
-export interface InitializeFormOptions {
-	readonly config: EngineConfig;
-
-	// E.g. opening a submitted form instance for edit. TDOO: the `FormResource`
-	// name is shared here for both init input and initial state, but the shape of
-	// those resources would differ. Probably a more generic name is appropriate.
-	readonly initialState?: FormResource;
-}
-
-/**
- * Creates an instance of a form to be filled (or edited) by a client.
- */
-// TODO: initialization is represented as asynchronous here, so that any
-// requisite resources can be retrieved before passing control to a client. This
-// is an obvious first step, but we can consider a more complex (if optional)
-// flow, e.g.:
-//
-// - Where it can be determined upfront that the form has no need to perform IO
-// - Where the IO may have already been performed (e.g. offline, other potential
-//   caching cases where appropriate)
-export type InitializeForm = (
-	input: FormResource,
-	options?: InitializeFormOptions
-) => Promise<RootNode>;
+export type * from './constants.ts';
+export * as constants from './constants.ts';
+export type * from './form/CreateFormInstance.ts';
+export type * from './form/FormInstance.ts';
+export type * from './form/FormInstanceConfig.ts';
+export type * from './form/FormResource.ts';
+export type * from './form/LoadForm.ts';
+export type * from './form/LoadFormResult.ts';
+export type * from './FormLanguage.ts';
+export type * from './GroupNode.ts';
+export type {
+	AnyChildNode,
+	AnyControlNode,
+	AnyLeafNode,
+	AnyNode,
+	AnyParentNode,
+	AnyUnsupportedControlNode,
+	GeneralChildNode,
+	GeneralParentNode,
+	RepeatRangeNode,
+} from './hierarchy.ts';
+export type * from './InputNode.ts';
+export type * from './ModelValueNode.ts';
+export type * from './NoteNode.ts';
+export type * from './OpaqueReactiveObjectFactory.ts';
+export type * from './RangeNode.ts';
+export type * from './RankNode.ts';
+export type * from './repeat/RepeatInstanceNode.ts';
+export type * from './repeat/RepeatRangeControlledNode.ts';
+export type * from './repeat/RepeatRangeUncontrolledNode.ts';
+export type * from './resources.ts';
+export type * from './RootNode.ts';
+export type * from './SelectNode.ts';
+export type * from './serialization/InstanceData.ts';
+export type * from './serialization/InstanceFile.ts';
+export type * from './serialization/InstancePayload.ts';
+export type * from './serialization/InstancePayloadOptions.ts';
+export type * from './serialization/InstanceState.ts';
+export type * from './submission/SubmissionMeta.ts';
+export type * from './SubtreeNode.ts';
+export type * from './TextRange.ts';
+export type * from './TriggerNode.ts';
+export type * from './unsupported/UploadNode.ts';
+export type * from './validation.ts';
+export type * from './ValueType.ts';
diff --git a/packages/xforms-engine/src/client/resources.ts b/packages/xforms-engine/src/client/resources.ts
index 288cb7ead..0f20078cf 100644
--- a/packages/xforms-engine/src/client/resources.ts
+++ b/packages/xforms-engine/src/client/resources.ts
@@ -1,5 +1,5 @@
 import type { JRResourceURL } from '@getodk/common/jr-resources/JRResourceURL.ts';
-import type { initializeForm } from '../instance/index.ts';
+import type { loadForm } from '../entrypoints/loadForm.ts';
 
 interface FetchResourceHeadersIterator<T>
 	extends IteratorObject<
@@ -85,7 +85,7 @@ export interface FetchResourceResponseHeaders {
  *
  * Furthermore, if the engine intends to read {@link body} (or its indirect
  * {@link blob} or {@link text} consumers), it will do so in the course of a
- * client's call to {@link initializeForm}, and before the
+ * client's call to {@link loadForm}, and before the
  * {@link Promise<PrimaryInstance>} returned by that call is resolved.
  */
 export interface FetchResourceResponse {
diff --git a/packages/xforms-engine/src/entrypoints/FormInstance.ts b/packages/xforms-engine/src/entrypoints/FormInstance.ts
new file mode 100644
index 000000000..c8a3e73cb
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/FormInstance.ts
@@ -0,0 +1,49 @@
+import { identity } from '@getodk/common/lib/identity.ts';
+import type {
+	FormInstance as ClientFormInstance,
+	FormInstanceInitializationMode,
+} from '../client/form/FormInstance.ts';
+import type { FormInstanceConfig } from '../client/index.ts';
+import type { InstanceConfig } from '../instance/internal-api/InstanceConfig.ts';
+import type { PrimaryInstanceOptions } from '../instance/PrimaryInstance.ts';
+import { PrimaryInstance } from '../instance/PrimaryInstance.ts';
+import type { Root } from '../instance/Root.ts';
+import type { FormSuccessResult } from './FormResult/FormSuccessResult.ts';
+import type { FormWarningResult } from './FormResult/FormWarningResult.ts';
+
+// prettier-ignore
+export type InstantiableFormResult =
+	| FormSuccessResult
+	| FormWarningResult;
+
+export interface FormInstanceBaseOptions extends Omit<PrimaryInstanceOptions, 'config'> {}
+
+interface FormInstanceOptions<Mode extends FormInstanceInitializationMode> {
+	readonly mode: Mode;
+	readonly instanceOptions: FormInstanceBaseOptions;
+	readonly instanceConfig: FormInstanceConfig;
+}
+
+export class FormInstance<Mode extends FormInstanceInitializationMode>
+	implements ClientFormInstance<Mode>
+{
+	readonly mode: Mode;
+	readonly root: Root;
+
+	constructor(
+		readonly formResult: InstantiableFormResult,
+		options: FormInstanceOptions<Mode>
+	) {
+		const config: InstanceConfig = {
+			clientStateFactory: options.instanceConfig.stateFactory ?? identity,
+		};
+		const primaryInstanceOptions: PrimaryInstanceOptions = {
+			...options.instanceOptions,
+			config,
+		};
+		const { root } = new PrimaryInstance(primaryInstanceOptions);
+
+		this.mode = options.mode;
+		this.root = root;
+	}
+}
diff --git a/packages/xforms-engine/src/entrypoints/FormResult/BaseFormResult.ts b/packages/xforms-engine/src/entrypoints/FormResult/BaseFormResult.ts
new file mode 100644
index 000000000..5fbbd4e04
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/FormResult/BaseFormResult.ts
@@ -0,0 +1,38 @@
+import type {
+	FormResultStatus,
+	LoadFormFailureResult,
+	LoadFormResult,
+	LoadFormSuccessResult,
+	LoadFormWarningResult,
+} from '../../client/form/LoadFormResult.ts';
+
+interface LoadFormResultByStatus {
+	readonly success: LoadFormSuccessResult;
+	readonly warning: LoadFormWarningResult;
+	readonly failure: LoadFormFailureResult;
+}
+
+export type BaseFormResultProperty<
+	Status extends FormResultStatus,
+	Key extends keyof LoadFormResult,
+> = LoadFormResultByStatus[Status][Key];
+
+export interface BaseFormResultOptions<Status extends FormResultStatus> {
+	readonly status: Status;
+	readonly warnings: BaseFormResultProperty<Status, 'warnings'>;
+	readonly error: BaseFormResultProperty<Status, 'error'>;
+}
+
+export abstract class BaseFormResult<Status extends FormResultStatus> {
+	readonly status: Status;
+	readonly warnings: BaseFormResultProperty<Status, 'warnings'>;
+	readonly error: BaseFormResultProperty<Status, 'error'>;
+
+	abstract readonly createInstance: BaseFormResultProperty<Status, 'createInstance'>;
+
+	constructor(options: BaseFormResultOptions<Status>) {
+		this.status = options.status;
+		this.warnings = options.warnings;
+		this.error = options.error;
+	}
+}
diff --git a/packages/xforms-engine/src/entrypoints/FormResult/BaseInstantiableFormResult.ts b/packages/xforms-engine/src/entrypoints/FormResult/BaseInstantiableFormResult.ts
new file mode 100644
index 000000000..bc2d34e3a
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/FormResult/BaseInstantiableFormResult.ts
@@ -0,0 +1,64 @@
+import type { CreateFormInstance } from '../../client/form/CreateFormInstance.ts';
+import type { FormInstanceConfig } from '../../client/form/FormInstanceConfig.ts';
+import type { FormResultStatus } from '../../client/form/LoadFormResult.ts';
+import { ErrorProductionDesignPendingError } from '../../error/ErrorProductionDesignPendingError.ts';
+import type { FormResource } from '../../instance/resource.ts';
+import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import type { FormInstanceBaseOptions, InstantiableFormResult } from '../FormInstance.ts';
+import { FormInstance } from '../FormInstance.ts';
+import type { BaseFormResultProperty } from './BaseFormResult.ts';
+import { BaseFormResult } from './BaseFormResult.ts';
+
+// prettier-ignore
+export type InstantiableFormResultStatus =
+	| 'success'
+	| 'warning';
+
+export interface BaseInstantiableFormResultOptions<Status extends InstantiableFormResultStatus> {
+	readonly status: Status;
+	readonly warnings: BaseFormResultProperty<Status, 'warnings'>;
+	readonly error: null;
+	readonly scope: ReactiveScope;
+	readonly formResource: FormResource;
+	readonly instanceOptions: FormInstanceBaseOptions;
+}
+
+export abstract class BaseInstantiableFormResult<
+	Status extends InstantiableFormResultStatus,
+> extends BaseFormResult<Status> {
+	readonly createInstance: CreateFormInstance;
+
+	constructor(options: BaseInstantiableFormResultOptions<Status>) {
+		const { status, warnings, error, instanceOptions } = options;
+
+		super({
+			status,
+			warnings,
+			error,
+		});
+
+		this.createInstance = (instanceConfig: FormInstanceConfig = {}) => {
+			this.assertInstantiable();
+
+			return new FormInstance(this, {
+				mode: 'create',
+				instanceOptions,
+				instanceConfig,
+			});
+		};
+	}
+
+	isInstantiable(): this is InstantiableFormResult {
+		const self: BaseFormResult<FormResultStatus> = this satisfies BaseFormResult<FormResultStatus>;
+
+		return self.status !== 'failure';
+	}
+
+	assertInstantiable(): asserts this is InstantiableFormResult {
+		if (!this.isInstantiable()) {
+			throw new ErrorProductionDesignPendingError(
+				'Failed to instantiate from result with status: "failure"'
+			);
+		}
+	}
+}
diff --git a/packages/xforms-engine/src/entrypoints/FormResult/FormFailureResult.ts b/packages/xforms-engine/src/entrypoints/FormResult/FormFailureResult.ts
new file mode 100644
index 000000000..bddc32de2
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/FormResult/FormFailureResult.ts
@@ -0,0 +1,38 @@
+import type { AnyFunction } from '@getodk/common/types/helpers.js';
+import type { CreateFormInstance } from '../../client/form/CreateFormInstance.ts';
+import type {
+	FailedLoadFormResultMethod,
+	LoadFormFailureResult,
+	LoadFormWarnings,
+} from '../../client/form/LoadFormResult.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>;
+
+	constructor(options: FormFailureOptions) {
+		const { error, warnings } = options;
+
+		super({
+			status: 'failure',
+			warnings,
+			error,
+		});
+
+		this.createInstance = failedFormResultMethodFactory(error);
+	}
+}
diff --git a/packages/xforms-engine/src/entrypoints/FormResult/FormSuccessResult.ts b/packages/xforms-engine/src/entrypoints/FormResult/FormSuccessResult.ts
new file mode 100644
index 000000000..3e7274f76
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/FormResult/FormSuccessResult.ts
@@ -0,0 +1,25 @@
+import type { LoadFormSuccessResult } from '../../client/index.ts';
+import type { FormResource } from '../../instance/resource.ts';
+import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import type { FormInstanceBaseOptions } from '../FormInstance.ts';
+import { BaseInstantiableFormResult } from './BaseInstantiableFormResult.ts';
+
+export interface FormSuccessResultOptions {
+	readonly warnings: null;
+	readonly error: null;
+	readonly scope: ReactiveScope;
+	readonly formResource: FormResource;
+	readonly instanceOptions: FormInstanceBaseOptions;
+}
+
+export class FormSuccessResult
+	extends BaseInstantiableFormResult<'success'>
+	implements LoadFormSuccessResult
+{
+	constructor(options: FormSuccessResultOptions) {
+		super({
+			status: 'success',
+			...options,
+		});
+	}
+}
diff --git a/packages/xforms-engine/src/entrypoints/FormResult/FormWarningResult.ts b/packages/xforms-engine/src/entrypoints/FormResult/FormWarningResult.ts
new file mode 100644
index 000000000..0c7ea429d
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/FormResult/FormWarningResult.ts
@@ -0,0 +1,25 @@
+import type { LoadFormWarningResult, LoadFormWarnings } from '../../client/form/LoadFormResult.ts';
+import type { FormResource } from '../../instance/resource.ts';
+import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
+import type { FormInstanceBaseOptions } from '../FormInstance.ts';
+import { BaseInstantiableFormResult } from './BaseInstantiableFormResult.ts';
+
+export interface FormWarningResultOptions {
+	readonly warnings: LoadFormWarnings;
+	readonly error: null;
+	readonly scope: ReactiveScope;
+	readonly formResource: FormResource;
+	readonly instanceOptions: FormInstanceBaseOptions;
+}
+
+export class FormWarningResult
+	extends BaseInstantiableFormResult<'warning'>
+	implements LoadFormWarningResult
+{
+	constructor(options: FormWarningResultOptions) {
+		super({
+			status: 'warning',
+			...options,
+		});
+	}
+}
diff --git a/packages/xforms-engine/src/entrypoints/createInstance.ts b/packages/xforms-engine/src/entrypoints/createInstance.ts
new file mode 100644
index 000000000..75480cf32
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/createInstance.ts
@@ -0,0 +1,23 @@
+import type { FormInstanceConfig } from '../client/form/FormInstanceConfig.ts';
+import type { LoadFormOptions } from '../client/form/LoadForm.ts';
+import type { CreatedFormInstance } from '../client/index.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);
+};
diff --git a/packages/xforms-engine/src/entrypoints/index.ts b/packages/xforms-engine/src/entrypoints/index.ts
new file mode 100644
index 000000000..f0547bd45
--- /dev/null
+++ b/packages/xforms-engine/src/entrypoints/index.ts
@@ -0,0 +1,2 @@
+export * from './createInstance.ts';
+export * from './loadForm.ts';
diff --git a/packages/xforms-engine/src/entrypoints/loadForm.ts b/packages/xforms-engine/src/entrypoints/loadForm.ts
new file mode 100644
index 000000000..96eb16753
--- /dev/null
+++ b/packages/xforms-engine/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;
diff --git a/packages/xforms-engine/src/error/LoadFormFailureError.ts b/packages/xforms-engine/src/error/LoadFormFailureError.ts
new file mode 100644
index 000000000..53cfbf330
--- /dev/null
+++ b/packages/xforms-engine/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;
+			}
+		}
+	}
+}
diff --git a/packages/xforms-engine/src/index.ts b/packages/xforms-engine/src/index.ts
index 91ea04c61..83da83f7a 100644
--- a/packages/xforms-engine/src/index.ts
+++ b/packages/xforms-engine/src/index.ts
@@ -1,46 +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/RangeNode.ts';
-export type * from './client/RankNode.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/serialization/InstanceData.ts';
-export type * from './client/serialization/InstanceFile.ts';
-export type * from './client/serialization/InstancePayload.ts';
-export type * from './client/serialization/InstancePayloadOptions.ts';
-export type * from './client/serialization/InstanceState.ts';
-export type * from './client/submission/SubmissionMeta.ts';
-export type * from './client/SubtreeNode.ts';
-export type * from './client/TextRange.ts';
-export type * from './client/TriggerNode.ts';
-export type * from './client/unsupported/UploadNode.ts';
-export type * from './client/validation.ts';
-export type * from './client/ValueType.ts';
+export * from './client/index.ts';
+export * from './entrypoints/index.ts';
diff --git a/packages/xforms-engine/src/instance/Group.ts b/packages/xforms-engine/src/instance/Group.ts
index d42fb6480..e9a1d2074 100644
--- a/packages/xforms-engine/src/instance/Group.ts
+++ b/packages/xforms-engine/src/instance/Group.ts
@@ -66,10 +66,6 @@ export class Group
 
 		this.childrenState = childrenState;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -84,7 +80,7 @@ export class Group
 				valueOptions: null,
 				value: null,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
@@ -96,7 +92,7 @@ export class Group
 		);
 
 		childrenState.setChildren(buildChildren(this));
-		this.validationState = createAggregatedViolations(this, sharedStateOptions);
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 		this.instanceState = createParentNodeInstanceState(this);
 	}
 
diff --git a/packages/xforms-engine/src/instance/InputControl.ts b/packages/xforms-engine/src/instance/InputControl.ts
index ec694ae32..aeca7978c 100644
--- a/packages/xforms-engine/src/instance/InputControl.ts
+++ b/packages/xforms-engine/src/instance/InputControl.ts
@@ -109,10 +109,6 @@ export class InputControl<V extends ValueType = ValueType>
 		this.appearances = definition.bodyElement.appearances;
 		this.nodeOptions = nodeOptionsFactoryByType[definition.valueType](definition.bodyElement);
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -128,7 +124,7 @@ export class InputControl<V extends ValueType = ValueType>
 				value: this.valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/ModelValue.ts b/packages/xforms-engine/src/instance/ModelValue.ts
index 9b07a92eb..fc5233da5 100644
--- a/packages/xforms-engine/src/instance/ModelValue.ts
+++ b/packages/xforms-engine/src/instance/ModelValue.ts
@@ -55,10 +55,6 @@ export class ModelValue<V extends ValueType = ValueType>
 
 		super(parent, definition, codec);
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -74,7 +70,7 @@ export class ModelValue<V extends ValueType = ValueType>
 				value: this.valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/Note.ts b/packages/xforms-engine/src/instance/Note.ts
index a1d179218..80a5eac70 100644
--- a/packages/xforms-engine/src/instance/Note.ts
+++ b/packages/xforms-engine/src/instance/Note.ts
@@ -59,10 +59,6 @@ export class Note<V extends ValueType = ValueType>
 
 		this.appearances = definition.bodyElement.appearances;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const isReadonly = createNoteReadonlyThunk(this, definition);
 		const noteTextComputation = createNoteText(this, definition.noteTextDefinition);
 
@@ -108,7 +104,7 @@ export class Note<V extends ValueType = ValueType>
 				value: this.valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/PrimaryInstance.ts b/packages/xforms-engine/src/instance/PrimaryInstance.ts
index d61f125f0..8c87c73bd 100644
--- a/packages/xforms-engine/src/instance/PrimaryInstance.ts
+++ b/packages/xforms-engine/src/instance/PrimaryInstance.ts
@@ -74,6 +74,13 @@ interface PrimaryInstanceStateSpec {
 	readonly activeLanguage: Accessor<ActiveLanguage>;
 }
 
+export interface PrimaryInstanceOptions {
+	readonly scope: ReactiveScope;
+	readonly model: ModelDefinition;
+	readonly secondaryInstances: SecondaryInstancesDefinition;
+	readonly config: InstanceConfig;
+}
+
 export class PrimaryInstance
 	extends InstanceNode<RootDefinition, PrimaryInstanceStateSpec, null, Root>
 	implements
@@ -118,15 +125,11 @@ export class PrimaryInstance
 	readonly evaluator: EngineXPathEvaluator;
 	override readonly contextNode = this;
 
-	constructor(
-		scope: ReactiveScope,
-		model: ModelDefinition,
-		secondaryInstances: SecondaryInstancesDefinition,
-		engineConfig: InstanceConfig
-	) {
+	constructor(options: PrimaryInstanceOptions) {
+		const { scope, model, secondaryInstances, config } = options;
 		const { root: definition } = model;
 
-		super(engineConfig, null, definition, {
+		super(config, null, definition, {
 			scope,
 			computeReference: () => PRIMARY_INSTANCE_REFERENCE,
 		});
@@ -170,9 +173,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;
diff --git a/packages/xforms-engine/src/instance/RangeControl.ts b/packages/xforms-engine/src/instance/RangeControl.ts
index 817a17319..e559b9208 100644
--- a/packages/xforms-engine/src/instance/RangeControl.ts
+++ b/packages/xforms-engine/src/instance/RangeControl.ts
@@ -73,10 +73,6 @@ export class RangeControl<V extends RangeValueType = RangeValueType>
 
 		this.appearances = definition.bodyElement.appearances;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -92,7 +88,7 @@ export class RangeControl<V extends RangeValueType = RangeValueType>
 				value: this.valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/RankControl.ts b/packages/xforms-engine/src/instance/RankControl.ts
index 306fa5175..0dc45d53f 100644
--- a/packages/xforms-engine/src/instance/RankControl.ts
+++ b/packages/xforms-engine/src/instance/RankControl.ts
@@ -150,10 +150,6 @@ export class RankControl
 			return createMemo(() => codec.encodeValue(getValue()));
 		});
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -168,7 +164,7 @@ export class RankControl
 				value: valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/Root.ts b/packages/xforms-engine/src/instance/Root.ts
index 01d96fc0c..b584de45d 100644
--- a/packages/xforms-engine/src/instance/Root.ts
+++ b/packages/xforms-engine/src/instance/Root.ts
@@ -98,10 +98,6 @@ export class Root
 		this.childrenState = childrenState;
 		this.languages = parent.languages;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -116,7 +112,7 @@ export class Root
 				value: null,
 				children: childrenState.childIds,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
@@ -128,7 +124,7 @@ export class Root
 		);
 
 		childrenState.setChildren(buildChildren(this));
-		this.validationState = createAggregatedViolations(this, sharedStateOptions);
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 		this.instanceState = createRootInstanceState(this);
 	}
 
diff --git a/packages/xforms-engine/src/instance/SelectControl.ts b/packages/xforms-engine/src/instance/SelectControl.ts
index e4a4ba51d..c1c21d5ea 100644
--- a/packages/xforms-engine/src/instance/SelectControl.ts
+++ b/packages/xforms-engine/src/instance/SelectControl.ts
@@ -123,10 +123,6 @@ export class SelectControl
 			});
 		});
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -142,7 +138,7 @@ export class SelectControl
 				value: valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/Subtree.ts b/packages/xforms-engine/src/instance/Subtree.ts
index ddc7f902a..a29ce1759 100644
--- a/packages/xforms-engine/src/instance/Subtree.ts
+++ b/packages/xforms-engine/src/instance/Subtree.ts
@@ -61,10 +61,6 @@ export class Subtree
 
 		this.childrenState = childrenState;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -79,7 +75,7 @@ export class Subtree
 				valueOptions: null,
 				value: null,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
@@ -91,7 +87,7 @@ export class Subtree
 		);
 
 		childrenState.setChildren(buildChildren(this));
-		this.validationState = createAggregatedViolations(this, sharedStateOptions);
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 		this.instanceState = createParentNodeInstanceState(this);
 	}
 
diff --git a/packages/xforms-engine/src/instance/TriggerControl.ts b/packages/xforms-engine/src/instance/TriggerControl.ts
index 333c52909..13530ab65 100644
--- a/packages/xforms-engine/src/instance/TriggerControl.ts
+++ b/packages/xforms-engine/src/instance/TriggerControl.ts
@@ -76,10 +76,6 @@ export class TriggerControl
 
 		this.appearances = definition.bodyElement.appearances;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -95,7 +91,7 @@ export class TriggerControl
 				value: this.valueState,
 				instanceValue: this.getInstanceValue,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/abstract/DescendantNode.ts b/packages/xforms-engine/src/instance/abstract/DescendantNode.ts
index 7665d1eb6..55b4b807f 100644
--- a/packages/xforms-engine/src/instance/abstract/DescendantNode.ts
+++ b/packages/xforms-engine/src/instance/abstract/DescendantNode.ts
@@ -131,7 +131,7 @@ export abstract class DescendantNode<
 		override readonly definition: Definition,
 		options?: DescendantNodeOptions
 	) {
-		super(parent.engineConfig, parent, definition, options);
+		super(parent.instanceConfig, parent, definition, options);
 
 		if (this.isRoot()) {
 			this.root = this;
diff --git a/packages/xforms-engine/src/instance/abstract/InstanceNode.ts b/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
index aae61dd45..9fd9fa024 100644
--- a/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
+++ b/packages/xforms-engine/src/instance/abstract/InstanceNode.ts
@@ -20,6 +20,7 @@ import type { SharedNodeState } from '../../lib/reactivity/node-state/createShar
 import type { ReactiveScope } from '../../lib/reactivity/scope.ts';
 import { createReactiveScope } from '../../lib/reactivity/scope.ts';
 import type { SimpleAtomicState } from '../../lib/reactivity/types.ts';
+import { createUniqueId } from '../../lib/unique-id.ts';
 import type { AnyNodeDefinition } from '../../parse/model/NodeDefinition.ts';
 import type { PrimaryInstance } from '../PrimaryInstance.ts';
 import type { Root } from '../Root.ts';
@@ -186,7 +187,7 @@ export abstract class InstanceNode<
 		this as AnyInstanceNode as PrimaryInstanceXPathNode;
 
 	constructor(
-		readonly engineConfig: InstanceConfig,
+		readonly instanceConfig: InstanceConfig,
 		readonly parent: Parent,
 		readonly definition: Definition,
 		options?: InstanceNodeOptions
@@ -208,8 +209,8 @@ export abstract class InstanceNode<
 		this.computeReference = options?.computeReference ?? this.computeChildStepReference;
 
 		this.scope = options?.scope ?? createReactiveScope();
-		this.engineConfig = engineConfig;
-		this.nodeId = nodeID(engineConfig.createUniqueId());
+		this.instanceConfig = instanceConfig;
+		this.nodeId = nodeID(createUniqueId());
 		this.definition = definition;
 	}
 
diff --git a/packages/xforms-engine/src/instance/abstract/UnsupportedControl.ts b/packages/xforms-engine/src/instance/abstract/UnsupportedControl.ts
index dd61fc37b..e43cdb289 100644
--- a/packages/xforms-engine/src/instance/abstract/UnsupportedControl.ts
+++ b/packages/xforms-engine/src/instance/abstract/UnsupportedControl.ts
@@ -123,10 +123,6 @@ export abstract class UnsupportedControl<Type extends UnsupportedControlNodeType
 
 		this.appearances = definition.bodyElement.appearances;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const stateSpec: UnsupportedControlStateSpec = {
 			reference: this.contextReference,
 			readonly: this.isReadonly,
@@ -140,12 +136,12 @@ export abstract class UnsupportedControl<Type extends UnsupportedControlNodeType
 			value: createValueState<unknown>(this),
 		};
 
-		const state = createSharedNodeState(this.scope, stateSpec, sharedStateOptions);
+		const state = createSharedNodeState(this.scope, stateSpec, this.instanceConfig);
 
 		this.state = state;
 		this.engineState = state.engineState;
 		this.currentState = state.currentState;
-		this.validation = createValidationState(this, sharedStateOptions);
+		this.validation = createValidationState(this, this.instanceConfig);
 		this.instanceState = createLeafNodeInsstanceState(this);
 	}
 
diff --git a/packages/xforms-engine/src/instance/abstract/ValueNode.ts b/packages/xforms-engine/src/instance/abstract/ValueNode.ts
index 300d1ff1a..1710baca7 100644
--- a/packages/xforms-engine/src/instance/abstract/ValueNode.ts
+++ b/packages/xforms-engine/src/instance/abstract/ValueNode.ts
@@ -106,9 +106,7 @@ export abstract class ValueNode<
 			return this.getInstanceValue();
 		};
 		this.valueState = valueState;
-		this.validation = createValidationState(this, {
-			clientStateFactory: this.engineConfig.stateFactory,
-		});
+		this.validation = createValidationState(this, this.instanceConfig);
 		this.instanceState = createValueNodeInstanceState(this);
 	}
 
diff --git a/packages/xforms-engine/src/instance/index.ts b/packages/xforms-engine/src/instance/index.ts
deleted file mode 100644
index fde1db369..000000000
--- a/packages/xforms-engine/src/instance/index.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { identity } from '@getodk/common/lib/identity.ts';
-import { getOwner } from 'solid-js';
-import type { EngineConfig } from '../client/EngineConfig.ts';
-import type { RootNode } from '../client/RootNode.ts';
-import { MISSING_RESOURCE_BEHAVIOR } from '../client/constants.ts';
-import type {
-	InitializeFormOptions as BaseInitializeFormOptions,
-	FormResource,
-	InitializeForm,
-} from '../client/index.ts';
-import { retrieveSourceXMLResource } from '../instance/resource.ts';
-import { createReactiveScope } from '../lib/reactivity/scope.ts';
-import { createUniqueId } from '../lib/unique-id.ts';
-import { XFormDOM } from '../parse/XFormDOM.ts';
-import { XFormDefinition } from '../parse/XFormDefinition.ts';
-import { SecondaryInstancesDefinition } from '../parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
-import { PrimaryInstance } from './PrimaryInstance.ts';
-import type { InstanceConfig } from './internal-api/InstanceConfig.ts';
-
-interface InitializeFormOptions extends BaseInitializeFormOptions {
-	readonly config: Partial<InstanceConfig>;
-}
-
-const buildInstanceConfig = (options: EngineConfig = {}): InstanceConfig => {
-	return {
-		createUniqueId,
-		fetchFormDefinition: options.fetchFormDefinition ?? fetch,
-		fetchFormAttachment: options.fetchFormAttachment ?? fetch,
-		missingResourceBehavior: options.missingResourceBehavior ?? MISSING_RESOURCE_BEHAVIOR.DEFAULT,
-		stateFactory: options.stateFactory ?? identity,
-	};
-};
-
-export const initializeForm = async (
-	input: FormResource,
-	options: Partial<InitializeFormOptions> = {}
-): Promise<RootNode> => {
-	const owner = getOwner();
-	const scope = createReactiveScope({ owner });
-	const engineConfig = buildInstanceConfig(options.config);
-	const sourceXML = await retrieveSourceXMLResource(input, {
-		fetchResource: engineConfig.fetchFormDefinition,
-	});
-	const xformDOM = XFormDOM.from(sourceXML);
-	const secondaryInstances = await SecondaryInstancesDefinition.load(xformDOM, {
-		fetchResource: engineConfig.fetchFormAttachment,
-		missingResourceBehavior: engineConfig.missingResourceBehavior,
-	});
-	const form = new XFormDefinition(xformDOM);
-	const primaryInstance = new PrimaryInstance(scope, form.model, secondaryInstances, engineConfig);
-
-	return primaryInstance.root;
-};
-
-initializeForm satisfies InitializeForm;
diff --git a/packages/xforms-engine/src/instance/internal-api/InstanceConfig.ts b/packages/xforms-engine/src/instance/internal-api/InstanceConfig.ts
index 0a3597185..60e468ef5 100644
--- a/packages/xforms-engine/src/instance/internal-api/InstanceConfig.ts
+++ b/packages/xforms-engine/src/instance/internal-api/InstanceConfig.ts
@@ -1,16 +1,9 @@
-import type { MissingResourceBehavior } from '../../client/constants.ts';
+import type { FormInstanceConfig } from '../../client/form/FormInstanceConfig.ts';
 import type { OpaqueReactiveObjectFactory } from '../../client/OpaqueReactiveObjectFactory.ts';
-import type { FetchFormAttachment, FetchResource } from '../../client/resources.ts';
-import type { CreateUniqueId } from '../../lib/unique-id.ts';
 
 export interface InstanceConfig {
-	readonly stateFactory: OpaqueReactiveObjectFactory;
-	readonly fetchFormDefinition: FetchResource;
-	readonly fetchFormAttachment: FetchFormAttachment;
-	readonly missingResourceBehavior: MissingResourceBehavior;
-
 	/**
-	 * Uniqueness per form instance session (so e.g. persistence isn't necessary).
+	 * @see {@link FormInstanceConfig.stateFactory}
 	 */
-	readonly createUniqueId: CreateUniqueId;
+	readonly clientStateFactory: OpaqueReactiveObjectFactory;
 }
diff --git a/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts b/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts
index 0f725ca1b..cf49e60d0 100644
--- a/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts
+++ b/packages/xforms-engine/src/instance/repeat/BaseRepeatRange.ts
@@ -160,10 +160,6 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 
 		this.childrenState = childrenState;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -178,7 +174,7 @@ export abstract class BaseRepeatRange<Definition extends AnyRepeatRangeDefinitio
 				valueOptions: null,
 				value: null,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
diff --git a/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts b/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts
index 555540862..777910a05 100644
--- a/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts
+++ b/packages/xforms-engine/src/instance/repeat/RepeatInstance.ts
@@ -126,10 +126,6 @@ export class RepeatInstance
 		this.childrenState = childrenState;
 		this.currentIndex = currentIndex;
 
-		const sharedStateOptions = {
-			clientStateFactory: this.engineConfig.stateFactory,
-		};
-
 		const state = createSharedNodeState(
 			this.scope,
 			{
@@ -145,7 +141,7 @@ export class RepeatInstance
 				valueOptions: null,
 				value: null,
 			},
-			sharedStateOptions
+			this.instanceConfig
 		);
 
 		this.state = state;
@@ -178,7 +174,7 @@ export class RepeatInstance
 		});
 
 		childrenState.setChildren(buildChildren(this));
-		this.validationState = createAggregatedViolations(this, sharedStateOptions);
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 		this.instanceState = createParentNodeInstanceState(this);
 	}
 
diff --git a/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts b/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts
index 49f6f8f8f..47eb9978d 100644
--- a/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts
+++ b/packages/xforms-engine/src/instance/repeat/RepeatRangeControlled.ts
@@ -24,12 +24,8 @@ export class RepeatRangeControlled
 		super(parent, definition);
 
 		this.appearances = definition.bodyElement.appearances;
-
 		this.initializeControlledChildrenState(definition);
-
-		this.validationState = createAggregatedViolations(this, {
-			clientStateFactory: this.engineConfig.stateFactory,
-		});
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 	}
 
 	private initializeControlledChildrenState(definition: ControlledRepeatRangeDefinition): void {
diff --git a/packages/xforms-engine/src/instance/repeat/RepeatRangeUncontrolled.ts b/packages/xforms-engine/src/instance/repeat/RepeatRangeUncontrolled.ts
index f1cdd3e07..81e343ebd 100644
--- a/packages/xforms-engine/src/instance/repeat/RepeatRangeUncontrolled.ts
+++ b/packages/xforms-engine/src/instance/repeat/RepeatRangeUncontrolled.ts
@@ -23,12 +23,8 @@ export class RepeatRangeUncontrolled
 		super(parent, definition);
 
 		this.appearances = definition.bodyElement.appearances;
-
 		this.addChildren(-1, definition.instances);
-
-		this.validationState = createAggregatedViolations(this, {
-			clientStateFactory: this.engineConfig.stateFactory,
-		});
+		this.validationState = createAggregatedViolations(this, this.instanceConfig);
 	}
 
 	// RepeatRangeUncontrolledNode
diff --git a/packages/xforms-engine/src/instance/resource.ts b/packages/xforms-engine/src/instance/resource.ts
index ee0afe805..b5f68655b 100644
--- a/packages/xforms-engine/src/instance/resource.ts
+++ b/packages/xforms-engine/src/instance/resource.ts
@@ -1,6 +1,6 @@
 import { UnreachableError } from '@getodk/common/lib/error/UnreachableError.ts';
 import { getBlobText } from '@getodk/common/lib/web-compat/blob.ts';
-import type { FormResource } from '../client/index.ts';
+import type { FormResource } from '../client/form/FormResource.ts';
 import type { FetchResource, FetchResourceResponse } from '../client/resources.ts';
 
 export type { FetchResource, FetchResourceResponse, FormResource };
@@ -76,3 +76,16 @@ export const retrieveSourceXMLResource = async (
 
 	return text;
 };
+
+interface RetrieveFormDefinitionOptions {
+	readonly fetchFormDefinition: FetchResource;
+}
+
+export const retrieveFormDefinition = async (
+	resource: FormResource,
+	options: RetrieveFormDefinitionOptions
+): Promise<ResourceXML> => {
+	return retrieveSourceXMLResource(resource, {
+		fetchResource: options.fetchFormDefinition,
+	});
+};
diff --git a/packages/xforms-engine/test/instance/PrimaryInstance.test.ts b/packages/xforms-engine/test/instance/PrimaryInstance.test.ts
index 9a88c02de..743cc6597 100644
--- a/packages/xforms-engine/test/instance/PrimaryInstance.test.ts
+++ b/packages/xforms-engine/test/instance/PrimaryInstance.test.ts
@@ -14,13 +14,10 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import type { ActiveLanguage } from '../../src/client/FormLanguage.ts';
 import type { OpaqueReactiveObjectFactory } from '../../src/client/OpaqueReactiveObjectFactory.ts';
 import type { RootNode } from '../../src/client/RootNode.ts';
-import { MISSING_RESOURCE_BEHAVIOR } from '../../src/client/constants.ts';
-import type { FetchResource } from '../../src/client/resources.ts';
 import { PrimaryInstance } from '../../src/instance/PrimaryInstance.ts';
 import { Root } from '../../src/instance/Root.ts';
 import { InstanceNode } from '../../src/instance/abstract/InstanceNode.ts';
 import { createReactiveScope, type ReactiveScope } from '../../src/lib/reactivity/scope.ts';
-import { createUniqueId } from '../../src/lib/unique-id.ts';
 import { XFormDOM } from '../../src/parse/XFormDOM.ts';
 import { XFormDefinition } from '../../src/parse/XFormDefinition.ts';
 import { SecondaryInstancesDefinition } from '../../src/parse/model/SecondaryInstance/SecondaryInstancesDefinition.ts';
@@ -72,22 +69,21 @@ describe('PrimaryInstance engine representation of instance state', () => {
 		scope.dispose();
 	});
 
-	const fetchResource: FetchResource = () => {
-		throw new Error('Nothing should fetch in these tests');
-	};
-
 	// Warning: this is a convenience function to slightly reduce repetitive
 	// boilerplate across tests. Most tests should use `createRootNode` below.
 	// Tests concerned with some aspects of internals may use this function
 	// directly, with caution.
-	const createPrimaryInstance = (stateFactory: OpaqueReactiveObjectFactory): PrimaryInstance => {
+	const createPrimaryInstance = (
+		clientStateFactory: OpaqueReactiveObjectFactory
+	): PrimaryInstance => {
 		return scope.runTask(() => {
-			return new PrimaryInstance(scope, xformDefinition.model, secondaryInstances, {
-				createUniqueId,
-				fetchFormAttachment: fetchResource,
-				fetchFormDefinition: fetchResource,
-				missingResourceBehavior: MISSING_RESOURCE_BEHAVIOR.DEFAULT,
-				stateFactory,
+			return new PrimaryInstance({
+				scope,
+				model: xformDefinition.model,
+				secondaryInstances,
+				config: {
+					clientStateFactory,
+				},
 			});
 		});
 	};
@@ -108,8 +104,8 @@ describe('PrimaryInstance engine representation of instance state', () => {
 	// with graph computations), but the majority of tests should be focused on
 	// client-facing functionality. Those tests should use this convenience
 	// function if possible.
-	const createRootNode = (stateFactory: OpaqueReactiveObjectFactory): RootNode => {
-		return createPrimaryInstance(stateFactory).root;
+	const createRootNode = (clientStateFactory: OpaqueReactiveObjectFactory): RootNode => {
+		return createPrimaryInstance(clientStateFactory).root;
 	};
 
 	it('creates a Root instance', () => {
diff --git a/packages/xforms-engine/test/instance/instance.test.ts b/packages/xforms-engine/test/instance/instance.test.ts
index 0008fe086..cd24aeddf 100644
--- a/packages/xforms-engine/test/instance/instance.test.ts
+++ b/packages/xforms-engine/test/instance/instance.test.ts
@@ -13,8 +13,8 @@ import {
 import { createRoot } from 'solid-js';
 import { createMutable } from 'solid-js/store';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createInstance } from '../../src/entrypoints/createInstance.ts';
 import type { AnyInputNode, AnyNode, RootNode } from '../../src/index.ts';
-import { initializeForm } from '../../src/index.ts';
 import { Root } from '../../src/instance/Root.ts';
 import { InstanceNode } from '../../src/instance/abstract/InstanceNode.ts';
 import type { AnyNode as AnyPrimaryInstanceNode } from '../../src/instance/hierarchy.ts';
@@ -34,25 +34,25 @@ interface IntializedTestForm {
 
 const initializeTestForm = async (xformXML: string): Promise<IntializedTestForm> => {
 	return createRoot(async (dispose) => {
-		const rootNode = await initializeForm(xformXML, {
-			config: {
+		const { root } = await createInstance(xformXML, {
+			instance: {
 				stateFactory: createMutable,
 			},
 		});
 
 		let internalRoot: Root;
 
-		if (rootNode instanceof Root) {
-			internalRoot = rootNode;
+		if (root instanceof Root) {
+			internalRoot = root;
 		} else {
 			expect.fail(
-				'Instance created with `initializeForm` is not an instance of `Root`. Testing internals will likely fail!'
+				'Instance created with `createInstance` is not an instance of `Root`. Testing internals will likely fail!'
 			);
 		}
 
 		return {
 			dispose,
-			rootNode,
+			rootNode: root,
 			internalRoot,
 		};
 	});
diff --git a/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts b/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts
index 03fdcfd81..9c2e101df 100644
--- a/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts
+++ b/packages/xforms-engine/test/lib/reactivity/createAggregatedViolations.test.ts
@@ -16,7 +16,8 @@ import {
 } from '@getodk/common/test/fixtures/xform-dsl/index.ts';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { VALIDATION_TEXT } from '../../../src/client/constants.ts';
-import { initializeForm, type ValidationCondition } from '../../../src/index.ts';
+import type { ValidationCondition } from '../../../src/client/validation.ts';
+import { createInstance } from '../../../src/entrypoints/createInstance.ts';
 import { reactiveTestScope } from '../../helpers/reactive/internal.ts';
 
 describe('createAggregatedViolations - reactive aggregated `constraint` and `required` validation violations on ancestor nodes', () => {
@@ -96,8 +97,8 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
 	describe('check assumptions: ensure observing violation state is effective', () => {
 		it('observes violations of a direct string input child', async () => {
 			const observed = await reactiveTestScope(async ({ effect, mutable }) => {
-				const root = await initializeForm(definition.asXml(), {
-					config: {
+				const { root } = await createInstance(definition.asXml(), {
+					instance: {
 						stateFactory: mutable,
 					},
 				});
@@ -159,8 +160,8 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
 
 		it('observes violations of a direct select child', async () => {
 			const observed = await reactiveTestScope(async ({ effect, mutable }) => {
-				const root = await initializeForm(definition.asXml(), {
-					config: {
+				const { root } = await createInstance(definition.asXml(), {
+					instance: {
 						stateFactory: mutable,
 					},
 				});
@@ -224,8 +225,8 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
 	describe('direct children', () => {
 		it('reactively updates when a direct string input child becomes valid', async () => {
 			const observed = await reactiveTestScope(async ({ effect, mutable }) => {
-				const root = await initializeForm(definition.asXml(), {
-					config: {
+				const { root } = await createInstance(definition.asXml(), {
+					instance: {
 						stateFactory: mutable,
 					},
 				});
@@ -302,8 +303,8 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
 
 		it('reactively updates when a direct select child becomes valid', async () => {
 			const observed = await reactiveTestScope(async ({ effect, mutable }) => {
-				const root = await initializeForm(definition.asXml(), {
-					config: {
+				const { root } = await createInstance(definition.asXml(), {
+					instance: {
 						stateFactory: mutable,
 					},
 				});
@@ -388,8 +389,8 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
 	describe('deeper descendants', () => {
 		it('reactively updates when a deeper string input descendant becomes valid', async () => {
 			const observed = await reactiveTestScope(async ({ effect, mutable }) => {
-				const root = await initializeForm(definition.asXml(), {
-					config: {
+				const { root } = await createInstance(definition.asXml(), {
+					instance: {
 						stateFactory: mutable,
 					},
 				});
@@ -483,8 +484,8 @@ describe('createAggregatedViolations - reactive aggregated `constraint` and `req
 
 		it('reactively updates when a deeper select descendant becomes valid', async () => {
 			const observed = await reactiveTestScope(async ({ effect, mutable }) => {
-				const root = await initializeForm(definition.asXml(), {
-					config: {
+				const { root } = await createInstance(definition.asXml(), {
+					instance: {
 						stateFactory: mutable,
 					},
 				});
diff --git a/packages/xforms-engine/test/lib/reactivity/createItemCollection.test.ts b/packages/xforms-engine/test/lib/reactivity/createItemCollection.test.ts
index 5d79903bd..11fa546dc 100644
--- a/packages/xforms-engine/test/lib/reactivity/createItemCollection.test.ts
+++ b/packages/xforms-engine/test/lib/reactivity/createItemCollection.test.ts
@@ -13,7 +13,7 @@ import {
 	title,
 } from '@getodk/common/test/fixtures/xform-dsl/index.ts';
 import { describe, expect, it } from 'vitest';
-import { initializeForm } from '../../../src/instance/index.ts';
+import { createInstance } from '../../../src/entrypoints/createInstance.ts';
 import type {
 	createItemCollection,
 	ItemCollectionControl,
@@ -214,8 +214,8 @@ describe('createItemCollection - reactive `<select>`/`<select1>`/`<odk:rank>` it
 			},
 		])('triggers translated select label - $description', async ({ act, assert }) => {
 			const labelStatesByValue = await reactiveTestScope(async ({ effect, mutable }) => {
-				const root = await initializeForm(fixture.asXml(), {
-					config: {
+				const { root } = await createInstance(fixture.asXml(), {
+					instance: {
 						stateFactory: mutable,
 					},
 				});