diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4246f12ad..cb294c11e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,8 @@
 # 7.0.0
+- Breaking: The generated ViewModel stubs for abstract model types have been replaced by static objects with a static `.load(id)` method that returns a standard `ItemApiState` caller. They are no longer exposed as instantiable proxy objects that mutate themselves into the correct implementation type after `$load`ing from the server - this approach did not fully satisfy the TypeScript contract of the derived types at runtime and otherwise attempted (and failed) to provide a concrete instance of a type that should not actually be instantiable.
+- API callers (`ItemApiState`, `ListApiState`) are now awaitable. `await caller` now resolves to `caller.result` after the current or previous operation is completed.
+  - `await vm.$load(1)` - performs a new load call and waits for completion
+  - `await vm.$load` - waits for completion of the pending load operation, or immediately resolves with the last result if no operation is pending.
 - `useAppUpdateCheck` now also listens for Vite's `vite:preloadError` event, showing the update notification when dynamic imports fail due to stale chunks after a deployment.
 
 # 6.6.0
diff --git a/playground/Coalesce.Web.Vue3/src/examples/core/abstract-viewmodel-load.vue b/playground/Coalesce.Web.Vue3/src/examples/core/abstract-viewmodel-load.vue
index 6f9d6f5a3..5c4d2fc4c 100644
--- a/playground/Coalesce.Web.Vue3/src/examples/core/abstract-viewmodel-load.vue
+++ b/playground/Coalesce.Web.Vue3/src/examples/core/abstract-viewmodel-load.vue
@@ -1,5 +1,5 @@
 <template>
-  <c-loader-status :loaders="{ '': [vm.$load] }" no-initial-content>
+  <c-loader-status :loaders="{ '': [loader] }" no-initial-content>
     {{ new Date().valueOf() }}
 
     {{ vm.id }}
@@ -16,7 +16,8 @@
 
 <script setup lang="ts">
 import { AbstractClassViewModel } from "@/viewmodels.g";
+import { computed } from "vue";
 
-const vm = new AbstractClassViewModel({});
-vm.$load(1);
+const loader = AbstractClassViewModel.load(1);
+const vm = computed(() => loader.result!);
 </script>
diff --git a/playground/Coalesce.Web.Vue3/src/viewmodels.g.ts b/playground/Coalesce.Web.Vue3/src/viewmodels.g.ts
index 72207e5fc..eed6d0cfe 100644
--- a/playground/Coalesce.Web.Vue3/src/viewmodels.g.ts
+++ b/playground/Coalesce.Web.Vue3/src/viewmodels.g.ts
@@ -3,10 +3,10 @@
 import * as $metadata from './metadata.g'
 import * as $models from './models.g'
 import * as $apiClients from './api-clients.g'
-import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractProxyViewModelType } from 'coalesce-vue/lib/viewmodel'
+import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractLoader } from 'coalesce-vue/lib/viewmodel'
 
 export type AbstractClassViewModel = AbstractClassImplViewModel
-export const AbstractClassViewModel = createAbstractProxyViewModelType<$models.AbstractClass, AbstractClassViewModel>($metadata.AbstractClass, $apiClients.AbstractClassApiClient)
+export const AbstractClassViewModel = createAbstractLoader<AbstractClassViewModel>($apiClients.AbstractClassApiClient, { DataSources: $models.AbstractClass.DataSources })
 
 export class AbstractClassListViewModel extends ListViewModel<$models.AbstractClass, $apiClients.AbstractClassApiClient, AbstractClassViewModel> {
   static DataSources = $models.AbstractClass.DataSources;
diff --git a/src/IntelliTect.Coalesce.CodeGeneration.Vue/Generators/Scripts/TsViewModels.cs b/src/IntelliTect.Coalesce.CodeGeneration.Vue/Generators/Scripts/TsViewModels.cs
index 81e07bacd..67efa22f7 100644
--- a/src/IntelliTect.Coalesce.CodeGeneration.Vue/Generators/Scripts/TsViewModels.cs
+++ b/src/IntelliTect.Coalesce.CodeGeneration.Vue/Generators/Scripts/TsViewModels.cs
@@ -19,7 +19,7 @@ public override Task<string> BuildOutputAsync()
         b.Line("import * as $metadata from './metadata.g'");
         b.Line("import * as $models from './models.g'");
         b.Line("import * as $apiClients from './api-clients.g'");
-        b.Line("import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractProxyViewModelType } from 'coalesce-vue/lib/viewmodel'");
+        b.Line("import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractLoader } from 'coalesce-vue/lib/viewmodel'");
         b.Line();
 
         foreach (var model in Model.CrudApiBackedClasses.OrderBy(e => e.ClientTypeName))
@@ -80,7 +80,14 @@ private void WriteViewModel(TypeScriptCodeBuilder b, ClassViewModel model)
         if (model.Type.IsAbstract)
         {
             b.Line($"export type {viewModelName} = {string.Join(" | ", model.ClientDerivedTypes.Select(t => new VueType(t.Type).TsType(viewModel: true)))}");
-            b.Line($"export const {viewModelName} = createAbstractProxyViewModelType<{modelName}, {viewModelName}>({metadataName}, $apiClients.{name}ApiClient)");
+            if (model.ClientDataSources(Model).Any())
+            {
+                b.Line($"export const {viewModelName} = createAbstractLoader<{viewModelName}>($apiClients.{name}ApiClient, {{ DataSources: {modelName}.DataSources }})");
+            }
+            else
+            {
+                b.Line($"export const {viewModelName} = createAbstractLoader<{viewModelName}>($apiClients.{name}ApiClient)");
+            }
             b.Line();
             return;
         }
diff --git a/src/coalesce-vue-vuetify3/src/components/c-metadata-component.ts b/src/coalesce-vue-vuetify3/src/components/c-metadata-component.ts
index 2416b76bc..9310bcb69 100644
--- a/src/coalesce-vue-vuetify3/src/components/c-metadata-component.ts
+++ b/src/coalesce-vue-vuetify3/src/components/c-metadata-component.ts
@@ -20,7 +20,6 @@ import type {
   BooleanValue,
   CollectionValue,
   ObjectValue,
-  ApiStateTypeWithArgs,
   ListViewModel,
   ServiceViewModel,
   ModelCollectionValue,
@@ -74,18 +73,10 @@ TModel extends Model ?
       }[keyof PropsOf<TModel>]
     
 // Handle binding of `:model` to an API caller (which binds values to the caller's args object):    
-: TModel extends ApiStateTypeWithArgs<
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  infer TMethod extends Method,
-  any,
-  infer TArgsObj,
-  any
-> ?
-  // HACK: Pulling types off of TArgsObj is a concession we make
-  // due to ApiStateTypeWithArgs's constituent types not actually capturing
-  // the type of their metadata. At some point this could be made better if
-  // we were able to pull metadata off of `TMethod. In other words, what we'd 
-  // really like to do here is do the same thing we do for props on a model.
+: TModel extends AnyArgCaller<any, infer TArgsObj> ?
+  // HACK: Pulling types off of TArgsObj is suboptimal. 
+  // Can we instead extract from `& { $metadata: infer TMethod extends Method }`,
+  // like we do for props on a model?
   | {
       [K in keyof TArgsObj]: TArgsObj[K] extends ((
         ValueKind extends ModelValue ? Model<ModelType> :
diff --git a/src/coalesce-vue-vuetify3/src/components/input/c-input.spec.tsx b/src/coalesce-vue-vuetify3/src/components/input/c-input.spec.tsx
index 5c89b26f7..623f78f76 100644
--- a/src/coalesce-vue-vuetify3/src/components/input/c-input.spec.tsx
+++ b/src/coalesce-vue-vuetify3/src/components/input/c-input.spec.tsx
@@ -149,7 +149,6 @@ describe("CInput", () => {
     //@ts-expect-error bad prop value
     () => <CInput model={model} for="color" variant="bad-variant" />;
 
-
     // ******
     // Enum filter
     // ******
diff --git a/src/coalesce-vue-vuetify3/src/components/input/c-input.vue b/src/coalesce-vue-vuetify3/src/components/input/c-input.vue
index 414e50b7d..3ae4469c6 100644
--- a/src/coalesce-vue-vuetify3/src/components/input/c-input.vue
+++ b/src/coalesce-vue-vuetify3/src/components/input/c-input.vue
@@ -38,7 +38,7 @@ type _ValueType<
   TModel extends Model | DataSource | AnyArgCaller | undefined,
   TFor extends ForSpec<TModel>,
 > =
-  TModel extends ApiStateTypeWithArgs<any, any, infer TArgsObj, any>
+  TModel extends AnyArgCaller<any, infer TArgsObj>
     ? TFor extends keyof TArgsObj
       ? TArgsObj[TFor]
       : any
@@ -69,26 +69,25 @@ type _ValueType<
 type _MetadataType<
   TModel extends Model | DataSource | AnyArgCaller | undefined,
   TFor extends ForSpec<TModel>,
-> =
-  TModel extends ApiStateTypeWithArgs<infer TMethod, any, any, any>
-    ? TMethod extends Method
-      ? TFor extends keyof TMethod["params"]
-        ? TMethod["params"][TFor]
-        : never
-      : never
-    : TFor extends Value
-      ? TFor
-      : TFor extends string
-        ? TFor extends keyof EnumTypeLookup
-          ? // Wrap in synthetic EnumValue so stage 2's guard is uniform.
-            // MetadataToModelType resolves this via typeDef.name → EnumTypeLookup.
-            EnumValue & { readonly typeDef: { readonly name: TFor } }
-          : TModel extends Model
-            ? TFor extends PropNames<TModel["$metadata"]>
-              ? TModel["$metadata"]["props"][TFor]
-              : never
+> = TModel extends AnyArgCaller & {
+  $metadata?: infer TMethod extends Method;
+}
+  ? TFor extends keyof TMethod["params"]
+    ? TMethod["params"][TFor]
+    : never
+  : TFor extends Value
+    ? TFor
+    : TFor extends string
+      ? TFor extends keyof EnumTypeLookup
+        ? // Wrap in synthetic EnumValue so stage 2's guard is uniform.
+          // MetadataToModelType resolves this via typeDef.name → EnumTypeLookup.
+          EnumValue & { readonly typeDef: { readonly name: TFor } }
+        : TModel extends Model
+          ? TFor extends PropNames<TModel["$metadata"]>
+            ? TModel["$metadata"]["props"][TFor]
             : never
-        : never;
+          : never
+      : never;
 
 type SelectSlotItemType<
   TModel extends Model | DataSource | AnyArgCaller | undefined,
@@ -211,7 +210,6 @@ import {
   type AnyArgCaller,
   mapValueToModel,
   parseValue,
-  ApiStateTypeWithArgs,
   ModelTypeLookup,
   PropNames,
   Value,
diff --git a/src/coalesce-vue-vuetify3/src/components/input/c-select.vue b/src/coalesce-vue-vuetify3/src/components/input/c-select.vue
index c3f8ee400..e216b9e23 100644
--- a/src/coalesce-vue-vuetify3/src/components/input/c-select.vue
+++ b/src/coalesce-vue-vuetify3/src/components/input/c-select.vue
@@ -270,7 +270,7 @@ type _SelectedModelType<
         | ModelValue
         | ForeignKeyProperty
     ? ValueOrFkToModelType<TFor>
-    : TModel extends ApiStateTypeWithArgs<any, any, infer TArgsObj, any>
+    : TModel extends AnyArgCaller<any, infer TArgsObj>
       ? TFor extends keyof TArgsObj
         ? TMultiple extends true
           ? TArgsObj[TFor] extends Array<any> | null | undefined
@@ -364,7 +364,6 @@ import {
   ModelTypeLookup,
   PrimaryKeyProperty,
   PropNames,
-  ApiStateTypeWithArgs,
   ModelCollectionValue,
   modelDisplay,
   MetadataToModelType,
diff --git a/src/coalesce-vue/src/api-client.ts b/src/coalesce-vue/src/api-client.ts
index 2bc93f19b..2557709e3 100644
--- a/src/coalesce-vue/src/api-client.ts
+++ b/src/coalesce-vue/src/api-client.ts
@@ -710,21 +710,10 @@ type TransportTypeSpecifier<T extends ApiRoutedType = any> =
 type ResultType<
   T extends TransportTypeSpecifier,
   TResult,
-  TNonResult = never,
 > = T extends ItemTransportTypeSpecifier
-  ? AxiosResponse<ItemResult<TResult>> | TNonResult
+  ? AxiosResponse<ItemResult<TResult>>
   : T extends ListTransportTypeSpecifier
-    ? AxiosResponse<ListResult<TResult>> | TNonResult
-    : never;
-
-type ResultPromiseType<
-  T extends TransportTypeSpecifier,
-  TResult,
-  TNonResult = never,
-> = T extends ItemTransportTypeSpecifier
-  ? Promise<AxiosResponse<ItemResult<TResult>> | TNonResult>
-  : T extends ListTransportTypeSpecifier
-    ? Promise<AxiosResponse<ListResult<TResult>> | TNonResult>
+    ? AxiosResponse<ListResult<TResult>>
     : never;
 
 type ApiCallerInvoker<
@@ -739,17 +728,59 @@ type ApiCallerArgsInvoker<TArgs, TReturn, TClient extends ApiClient<any>> = (
   args: TArgs,
 ) => TReturn;
 
-export type ApiStateType<
+/** Extracts the data type from an invoker's return type.
+ * For item endpoints: R from AxiosResponse<ItemResult<R>>.
+ * For list endpoints: R[] from AxiosResponse<ListResult<R>>. */
+type InferResultData<T extends TransportTypeSpecifier, TReturn> =
+  Extract<
+    Awaited<Extract<TReturn, Promise<any>>>,
+    AxiosResponse<any>
+  > extends AxiosResponse<infer TData>
+    ? T extends ItemTransportTypeSpecifier
+      ? TData extends ItemResult<infer R>
+        ? R
+        : never
+      : T extends ListTransportTypeSpecifier
+        ? TData extends ListResult<infer R>
+          ? R[]
+          : never
+        : never
+    : never;
+
+/** Evaluates to `undefined` if the invoker's return type indicates
+ * the API call may be conditionally skipped (returns void/undefined). */
+type InferVoidable<TReturn> = void extends TReturn
+  ? undefined
+  : undefined extends TReturn
+    ? undefined
+    : undefined extends Awaited<Extract<TReturn, Promise<any>>>
+      ? undefined
+      : never;
+
+/** The full result type for an API caller, combining the data type with voidability. */
+type InferCallerResult<T extends TransportTypeSpecifier, TReturn> =
+  | InferResultData<T, TReturn>
+  | InferVoidable<TReturn>;
+
+type MakeCallerResult<
   T extends TransportTypeSpecifier,
   TArgs extends any[],
-  TResult,
+  TReturn,
 > = T extends ItemTransportTypeSpecifier
-  ? ItemApiState<TArgs, TResult, T extends ItemMethod ? T : ItemMethod>
+  ? ItemApiState<
+      TArgs,
+      InferCallerResult<T, TReturn>,
+      T extends ItemMethod ? T : ItemMethod
+    >
   : T extends ListTransportTypeSpecifier
-    ? ListApiState<TArgs, TResult, T extends ListMethod ? T : ListMethod>
+    ? ListApiState<
+        TArgs,
+        InferCallerResult<T, TReturn>,
+        T extends ListMethod ? T : ListMethod
+      >
     : never;
 
-export type ApiStateTypeWithArgs<
+type MakeArgsCallerResult<
   T extends TransportTypeSpecifier,
   TArgs extends any[],
   TArgsObj extends object,
@@ -841,79 +872,59 @@ export class ApiClient<T extends ApiRoutedType> {
     return clone;
   }
 
+  // $makeCaller uses a single overload per variant (no-args and with-args).
+  // TReturn is captured from the invoker, and conditional types (InferResultData, InferVoidable)
+  // extract the data type and detect whether the invoker can return void/undefined.
+
   /**
    * Create a wrapper function for an API call. This function maintains properties which represent the state of its previous invocation.
    * @param resultType An indicator of whether the API endpoint returns an ItemResult<T> or a ListResult<T>
-   * @param invokerFactory method that will call the API. The signature of the function, minus the apiClient parameter, will be the call signature of the wrapper.
+   * @param invoker method that will call the API. The signature of the function, minus the apiClient parameter, will be the call signature of the wrapper.
    */
   $makeCaller<
     TArgs extends any[],
-    TResult,
+    TReturn extends Promise<any> | undefined | void,
     TTransportType extends TransportTypeSpecifier<T>,
   >(
     resultType: TTransportType,
-    invoker: ApiCallerInvoker<
-      TArgs,
-      | ResultPromiseType<TTransportType, TResult, undefined | void>
-      | undefined
-      | void,
-      this
-    >,
-  ): ApiStateType<TTransportType, TArgs, TResult>;
+    invoker: ApiCallerInvoker<TArgs, TReturn, this>,
+  ): MakeCallerResult<TTransportType, TArgs, TReturn>;
 
   /**
    * Create a wrapper function for an API call. This function maintains properties which represent the state of its previous invocation.
    * @param resultType An indicator of whether the API endpoint returns an ItemResult<T> or a ListResult<T>
-   * @param invokerFactory method that will call the API. The signature of the function, minus the apiClient parameter, will be the call signature of the wrapper.
-   * @param invokerFactory method that will call the API with an args object as the only parameter. This may be called by using `.withArgs()` on the function that is returned from `$makeCaller`. The value of the args object will default to `.args` if not specified.
+   * @param invoker method that will call the API. The signature of the function, minus the apiClient parameter, will be the call signature of the wrapper.
+   * @param argsFactory A factory function that will create the args object for the method.
+   * @param argsInvoker method that will call the API with an args object as the only parameter. This may be called by using `.withArgs()` on the function that is returned from `$makeCaller`. The value of the args object will default to `.args` if not specified.
    */
   $makeCaller<
     TArgs extends any[],
     TArgsObj extends object,
-    TResult,
+    TReturn extends Promise<any> | undefined | void,
     TTransportType extends TransportTypeSpecifier<T>,
   >(
     resultType: TTransportType,
-    invoker: ApiCallerInvoker<
-      TArgs,
-      | ResultPromiseType<TTransportType, TResult, undefined | void>
-      | undefined
-      | void,
-      this
-    >,
+    invoker: ApiCallerInvoker<TArgs, TReturn, this>,
     argsFactory: () => TArgsObj,
-    argsInvoker: ApiCallerArgsInvoker<
-      TArgsObj,
-      | ResultPromiseType<TTransportType, TResult, undefined | void>
-      | undefined
-      | void,
-      this
-    >,
-  ): ApiStateTypeWithArgs<TTransportType, TArgs, TArgsObj, TResult>;
+    argsInvoker: ApiCallerArgsInvoker<TArgsObj, TReturn, this>,
+  ): MakeArgsCallerResult<
+    TTransportType,
+    TArgs,
+    TArgsObj,
+    InferCallerResult<TTransportType, TReturn>
+  >;
 
   $makeCaller<
     TArgs extends any[],
     TArgsObj extends object,
-    TResult,
+    TReturn extends Promise<any> | undefined | void,
     TTransportType extends TransportTypeSpecifier<T>,
   >(
     resultType: TTransportType,
-    invoker: ApiCallerInvoker<
-      TArgs,
-      | ResultPromiseType<TTransportType, TResult, undefined | void>
-      | undefined
-      | void,
-      this
-    >,
+    invoker: ApiCallerInvoker<TArgs, TReturn, this>,
     argsFactory?: () => TArgsObj,
-    argsInvoker?: ApiCallerArgsInvoker<
-      TArgsObj,
-      | ResultPromiseType<TTransportType, TResult, undefined | void>
-      | undefined
-      | void,
-      this
-    >,
-  ): any {
+    argsInvoker?: ApiCallerArgsInvoker<TArgsObj, TReturn, this>,
+  ) {
     let localResultType: TransportTypeSpecifier<T> = resultType;
     let meta: Method | undefined = undefined;
     if (typeof localResultType === "function") {
@@ -931,7 +942,7 @@ export class ApiClient<T extends ApiRoutedType> {
     if (argsFactory && argsInvoker) {
       switch (localResultType) {
         case "item":
-          instance = new ItemApiStateWithArgs<TArgs, TArgsObj, TResult>(
+          instance = new ItemApiStateWithArgs(
             this,
             invoker as any,
             argsFactory,
@@ -939,7 +950,7 @@ export class ApiClient<T extends ApiRoutedType> {
           );
           break;
         case "list":
-          instance = new ListApiStateWithArgs<TArgs, TArgsObj, TResult>(
+          instance = new ListApiStateWithArgs(
             this,
             invoker as any,
             argsFactory,
@@ -952,10 +963,10 @@ export class ApiClient<T extends ApiRoutedType> {
     } else {
       switch (localResultType) {
         case "item":
-          instance = new ItemApiState<TArgs, TResult>(this, invoker as any);
+          instance = new ItemApiState(this, invoker as any);
           break;
         case "list":
-          instance = new ListApiState<TArgs, TResult>(this, invoker as any);
+          instance = new ListApiState(this, invoker as any);
           break;
         default:
           throw `Unknown result type ${localResultType}`;
@@ -1405,9 +1416,9 @@ abstract class ApiStateBase<TArgs extends any[], TResult> {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     invoker: Function,
     args: any[],
-  ): Promise<ItemResult<TResult> | ListResult<TResult>>;
+  ): Promise<TResult>;
 
-  protected _pendingPromise: Promise<any> | undefined;
+  protected _pendingPromise: Promise<TResult> | undefined;
 
   constructor(
     apiClient: ApiClient<any>,
@@ -1461,7 +1472,7 @@ export abstract class ApiState<
   /** The metadata of the method being called, if it was provided. */
   abstract $metadata?: Method;
 
-  abstract result: TResult | TResult[] | null;
+  abstract result: Exclude<TResult, undefined> | null;
 
   private readonly __isLoading = ref(false);
   /** True if a request is currently pending. */
@@ -1669,6 +1680,31 @@ export abstract class ApiState<
     return this;
   }
 
+  /**
+   * Returns the promise of the currently pending request,
+   * or `undefined` if no request is pending.
+   */
+  getPromise() {
+    return this._pendingPromise;
+  }
+
+  /**
+   * Implements the thenable protocol, allowing the caller to be used with `await`.
+   * If a request is currently pending, awaits that request.
+   * If no request is pending, resolves immediately with the current `result` value.
+   */
+  then<TResult1 = TResult | null, TResult2 = never>(
+    onfulfilled?:
+      | ((value: TResult | null) => TResult1 | PromiseLike<TResult1>)
+      | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return (this._pendingPromise ?? Promise.resolve(this.result)).then(
+      onfulfilled,
+      onrejected,
+    );
+  }
+
   protected abstract setResponseProps(data: ApiResult): void;
 
   private _debounceSignal: {
@@ -1682,7 +1718,7 @@ export abstract class ApiState<
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     invoker: Function,
     args: any[],
-  ) {
+  ): Promise<TResult> {
     let apiClient = this.apiClient;
 
     if (this.isLoading) {
@@ -1718,6 +1754,10 @@ export abstract class ApiState<
             // Similar to the "cancel" mode,
             // aborted requests are not thrown as rejected promises,
             // but instead as a fulfilled promise with a void resolved value.
+
+            // @ts-expect-error This is a deliberate and long-standing break from the
+            // type contract of ApiState objects that prematurely halted requests
+            // resolve to undefined (added in 7300ac92aaa9cd577fe461717fa78b98c73174ac).
             return undefined;
           }
       }
@@ -1858,6 +1898,11 @@ export abstract class ApiState<
 
       if (!promise) {
         this.isLoading = false;
+
+        // @ts-expect-error Added in 2833516271642f65a29e494cd4aa10a2861671be - it is deliberate
+        // that invoker funcs that return undefined are treated as a cancellation
+        // and return undefined (in violation of the type contract) like other cancellations.
+        // Note that this is exceedingly rare and would require the invoker func to not be async.
         return undefined;
       }
 
@@ -1865,6 +1910,9 @@ export abstract class ApiState<
 
       if (!resp) {
         this.isLoading = false;
+
+        // @ts-expect-error Added for https://github.com/IntelliTect/Coalesce/issues/416 -
+        // similar to just above, this allows async invoker funcs to return undefined.
         return undefined;
       }
 
@@ -1885,7 +1933,9 @@ export abstract class ApiState<
 
       this.isLoading = false;
 
-      return data?.object ?? data?.list;
+      // NB: `this.result` will have been set non-null in `setResponseProps`
+      // (or if it IS null, null should be in TResult as a valid result type).
+      return this.result! as TResult;
     } catch (thrown) {
       if (axios.isCancel(thrown)) {
         // No handling of anything for cancellations.
@@ -1894,6 +1944,10 @@ export abstract class ApiState<
         // it should probably be implemented as a separate set of callbacks.
         // We don't set isLoading to false here - we set it in the cancel() method to ensure that we don't set isLoading=false for a subsequent call,
         // since the promise won't reject immediately after requesting cancellation. There could already be another request pending when this code is being executed.
+
+        // @ts-expect-error This is a deliberate and long-standing break from the
+        // type contract of ApiState objects that prematurely halted requests
+        // resolve to undefined (added in 7300ac92aaa9cd577fe461717fa78b98c73174ac).
         return;
       } else if (
         windowUnloading &&
@@ -1906,7 +1960,16 @@ export abstract class ApiState<
         // This seems to only happen on Firefox - Chrome doesn't abort requests
         // on unload in a way that ever propagates up to user code.
         // https://github.com/IntelliTect/Coalesce/issues/296
-        return;
+
+        // Wait 1s matching the windowUnloading reset timer. If the page truly unloads,
+        // nothing matters. If the unload was user-canceled, this gives the browser time
+        // to reset before we resolve, avoiding spurious downstream continuations.
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+
+        // @ts-expect-error This is a deliberate and long-standing break from the
+        // type contract of ApiState objects that prematurely halted requests
+        // resolve to undefined (added in 7300ac92aaa9cd577fe461717fa78b98c73174ac).
+        return undefined;
       } else {
         // eslint-disable-next-line no-var
         var error = thrown as AxiosError | ApiResult | Error | string;
@@ -2014,14 +2077,6 @@ export class ItemApiState<
   /** The metadata of the method being called, if it was provided. */
   $metadata?: TMethod;
 
-  /**
-   * Returns the promise of the currently pending request,
-   * or `undefined` if no request is pending.
-   */
-  getPromise(): Promise<TResult> | undefined {
-    return this._pendingPromise;
-  }
-
   private readonly __validationIssues = ref<ValidationIssue[] | null>(null);
   /** Validation issues returned by the previous request. */
   get validationIssues() {
@@ -2031,12 +2086,14 @@ export class ItemApiState<
     this.__validationIssues.value = v;
   }
 
-  private readonly __result = ref<TResult | null>(null) as Ref<TResult | null>;
+  private readonly __result = ref<Exclude<TResult, undefined> | null>(
+    null,
+  ) as Ref<Exclude<TResult, undefined> | null>;
   /** Principal data returned by the previous request. */
-  get result() {
+  get result(): Exclude<TResult, undefined> | null {
     return this.__result.value;
   }
-  set result(v) {
+  set result(v: Exclude<TResult, undefined> | null) {
     this.__result.value = v;
     if (this.$metadata?.return.type == "void") {
       this.hasResult = !!this.wasSuccessful;
@@ -2046,7 +2103,9 @@ export class ItemApiState<
   }
 
   override get rawResponse() {
-    return super.rawResponse as AxiosResponse<ItemResult<TResult>>;
+    return super.rawResponse as AxiosResponse<
+      ItemResult<Exclude<TResult, undefined>>
+    >;
   }
 
   constructor(
@@ -2139,7 +2198,7 @@ export class ItemApiState<
       this.validationIssues = null;
     }
     if ("object" in data) {
-      this.result = data.object ?? null;
+      this.result = (data.object ?? null) as Exclude<TResult, undefined> | null;
     } else {
       this.result = null;
     }
@@ -2220,13 +2279,13 @@ export class ItemApiStateWithArgs<
     apiClient: ApiClient<any>,
     invoker: ApiCallerInvoker<
       TArgs,
-      ItemResultPromise<TResult>,
+      ApiResultPromise<TResult> | undefined | void,
       ApiClient<any>
     >,
     private argsFactory: () => TArgsObj,
     private argsInvoker: ApiCallerArgsInvoker<
       TArgsObj,
-      ItemResultPromise<TResult>,
+      ApiResultPromise<TResult> | undefined | void,
       ApiClient<any>
     >,
   ) {
@@ -2235,9 +2294,14 @@ export class ItemApiStateWithArgs<
   }
 }
 
-export interface ListApiState<TArgs extends any[], TResult> {
+export interface ListApiState<
+  TArgs extends any[],
+  TResult,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  TMethod extends ListMethod | undefined = ListMethod,
+> {
   /** Invokes a call to this API endpoint. */
-  (...args: TArgs): Promise<TResult[]>;
+  (...args: TArgs): Promise<TResult>;
 }
 export class ListApiState<
   TArgs extends any[],
@@ -2247,14 +2311,6 @@ export class ListApiState<
   /** The metadata of the method being called, if it was provided. */
   $metadata?: TMethod;
 
-  /**
-   * Returns the promise of the currently pending request,
-   * or `undefined` if no request is pending.
-   */
-  getPromise(): Promise<TResult[]> | undefined {
-    return this._pendingPromise;
-  }
-
   private readonly __page = ref<number | null>(null);
   /** Page number returned by the previous request. */
   get page() {
@@ -2291,20 +2347,22 @@ export class ListApiState<
     this.__totalCount.value = v;
   }
 
-  private readonly __result = ref<TResult[] | null>(null) as Ref<
-    TResult[] | null
-  >;
+  private readonly __result = ref<Exclude<TResult, undefined> | null>(
+    null,
+  ) as Ref<Exclude<TResult, undefined> | null>;
   /** Principal data returned by the previous request. */
-  get result() {
+  get result(): Exclude<TResult, undefined> | null {
     return this.__result.value;
   }
-  set result(v) {
+  set result(v: Exclude<TResult, undefined> | null) {
     this.__result.value = v;
     this.hasResult = v != null;
   }
 
   override get rawResponse() {
-    return super.rawResponse as AxiosResponse<ListResult<TResult>>;
+    return super.rawResponse as AxiosResponse<
+      ListResult<Exclude<TResult, undefined> extends (infer R)[] ? R : never>
+    >;
   }
 
   constructor(
@@ -2327,7 +2385,11 @@ export class ListApiState<
     this.page = null;
   }
 
-  protected setResponseProps(data: ListResult<TResult>) {
+  protected setResponseProps(
+    data: ListResult<
+      Exclude<TResult, undefined> extends (infer R)[] ? R : never
+    >,
+  ) {
     this.wasSuccessful = data.wasSuccessful;
     this.message = data.message || null;
 
@@ -2337,7 +2399,7 @@ export class ListApiState<
     this.totalCount = data.totalCount ?? null;
 
     if ("list" in data) {
-      this.result = data.list || [];
+      this.result = (data.list || []) as Exclude<TResult, undefined> | null;
     } else {
       this.result = null;
     }
@@ -2397,13 +2459,13 @@ export class ListApiStateWithArgs<
     apiClient: ApiClient<any>,
     invoker: ApiCallerInvoker<
       TArgs,
-      ListResultPromise<TResult>,
+      ApiResultPromise<TResult> | undefined | void,
       ApiClient<any>
     >,
     private argsFactory: () => TArgsObj,
     private argsInvoker: ApiCallerArgsInvoker<
       TArgsObj,
-      ListResultPromise<TResult>,
+      ApiResultPromise<TResult> | undefined | void,
       ApiClient<any>
     >,
   ) {
diff --git a/src/coalesce-vue/src/viewmodel.ts b/src/coalesce-vue/src/viewmodel.ts
index 548088c51..9e8214ce3 100644
--- a/src/coalesce-vue/src/viewmodel.ts
+++ b/src/coalesce-vue/src/viewmodel.ts
@@ -1360,134 +1360,40 @@ export abstract class ViewModel<
   }
 }
 
-const $loadProxy = Symbol("$loadProxy");
-const $protoVersion = Symbol("$protoVersion");
-/** Create a class that represents an abstract model type
- * and will turn itself into the proper concrete ViewModel type
- * when loaded.
- */
-export function createAbstractProxyViewModelType<
-  TModel extends Model<ModelType>,
+export function createAbstractLoader<
   TViewModel extends ViewModel,
+  TMixin extends object = object,
 >(
-  metadata: ModelType,
   apiClientCtor: { new (): ModelApiClient<any> },
-): {
-  new (initialData?: DeepPartial<TModel> | null): TViewModel;
+  mixin?: TMixin,
+): TMixin & {
+  readonly apiClient: ModelApiClient<any>;
+  load(
+    id: any,
+    parameters?: DataSourceParameters,
+  ): ItemApiState<[id?: any], TViewModel>;
 } {
-  function unsupportedError() {
-    return new Error(`"Operation not supported: This ViewModel instance is a proxy for an abstract type, with its concrete implementation not yet decided.
-
-      Try one of the following to obtain a concrete implementation:
-        - $load(...) or $loadFromModel(...) data for a concrete implementation
-        - Instantiate a concrete implementation of this abstract type instead of this abstract proxy
-      `);
-  }
-
-  class AbstractVmProxy extends ViewModel<TModel, ModelApiClient<TModel>> {
-    [$loadProxy]?: ItemApiState<any, any, any>;
-    [$protoVersion]? = ref(0);
-
-    override get $load() {
-      return this[$loadProxy]!;
-    }
-    override get $save() {
-      return this.$apiClient.$makeCaller("item", (c) => {
-        throw unsupportedError();
-      }) as any;
-    }
-    override get $bulkSave() {
-      return this.$apiClient.$makeCaller("item", (c) => {
-        throw unsupportedError();
-      }) as any;
-    }
-    override get $delete() {
-      return this.$apiClient.$makeCaller("item", (c) => {
-        throw unsupportedError();
-      }) as any;
-    }
-
-    constructor(initialDirtyData?: any) {
-      if (
-        initialDirtyData &&
-        "$metadata" in initialDirtyData &&
-        ViewModel.typeLookup?.[initialDirtyData.$metadata.name]
-      ) {
-        // We know the real concrete type of this ViewModel from the metadata.
-        // Return the proper instance directly, bypassing the conversion process.
-        return ViewModelFactory.get(
-          initialDirtyData.$metadata.name,
-          initialDirtyData,
-          false,
-        ) as any;
-      }
-
-      super(metadata, new apiClientCtor(), initialDirtyData);
-
-      // eslint-disable-next-line @typescript-eslint/no-this-alias
-      const vm = this;
-
-      let $load = (vm[$loadProxy] = vm.$apiClient
-        .$makeCaller("item", (c, id?: any) => {
-          return c.get(id != null ? id : vm.$primaryKey, vm.$params);
-        })
+  const apiClient = new apiClientCtor();
+  return {
+    ...mixin,
+    apiClient,
+    load(
+      id: any,
+      parameters?: DataSourceParameters,
+    ): ItemApiState<[id?: any], TViewModel> {
+      const caller = apiClient
+        .$makeCaller("item", (c, id?: any) => c.get(id, parameters))
         .onFulfilled((state) => {
-          const result = state.result!;
-
-          const realCtor = ViewModel.typeLookup![result.$metadata.name];
-
-          // Grab real metadata and API client instances of the concrete type.
-          const { $apiClient, $metadata } = new realCtor();
-
-          // Update the tracking ref for prototype version so that instanceof is reactive.
-          vm[$protoVersion]!.value++;
-          delete vm[$protoVersion];
-
-          // Convert the ViewModel instance to the target type:
-          Object.setPrototypeOf(vm, realCtor.prototype);
-
-          // Convert the ApiClient instance to the target type:
-          Object.setPrototypeOf(
-            vm.$apiClient,
-            Object.getPrototypeOf($apiClient),
-          );
-          vm.$apiClient.$metadata = $metadata;
-
-          // Update $data.$metadata so it reflects the concrete type.
-          (vm as any).$data.$metadata = $metadata;
-
-          // Populate the properties of the $load caller on the real $load caller instance.
-          //@ts-expect-error protected prop or fn
-          vm.$load.setResponseProps($load.rawResponse.data);
-          //@ts-expect-error protected prop or fn
-          vm.$load.__rawResponse.value = $load.rawResponse;
-          vm.$load.isLoading = false;
-          vm.$load.concurrencyMode = $load.concurrencyMode;
-
-          //@ts-expect-error cleaning up for GC
-          $load = undefined;
-          delete vm[$loadProxy];
-
-          vm.$loadCleanData(result);
-        }));
-    }
-  }
-
-  Object.defineProperty(AbstractVmProxy, "name", {
-    value: metadata.name + "ViewModelProxy",
-  });
-
-  defineProps(AbstractVmProxy, metadata);
-
-  // Make `$metadata` reactive so components depending on it update when it changes.
-  Object.defineProperty(AbstractVmProxy.prototype, "$metadata", {
-    get() {
-      this[$protoVersion]?.value.toString();
-      return metadata;
+          const data = state.result!;
+          const realCtor = ViewModel.typeLookup![data.$metadata.name];
+          const vm = (new realCtor() as TViewModel).$loadCleanData(data as any);
+          if (parameters) vm.$params = parameters;
+          state.result = vm as any;
+        });
+      caller(id);
+      return caller as ItemApiState<[id?: any], TViewModel>;
     },
-  });
-
-  return AbstractVmProxy as any;
+  } as any;
 }
 
 export interface BulkSaveRequestRawItem {
@@ -2295,18 +2201,6 @@ export function defineProps<T extends new () => ViewModel>(
   const props = Object.values(metadata.props);
   const descriptors = {} as PropertyDescriptorMap;
 
-  if (metadata.baseTypes?.some((base) => base.abstract)) {
-    // Make the `instanceof` operator against this type reactive if the type
-    // has a known abstract base class such that an instance could change types via AbstractVmProxy
-    Object.defineProperty(ctor, Symbol.hasInstance, {
-      value(x: any) {
-        // Take a dependency, tracked per instance, that will update when the instance changes type.
-        x[$protoVersion]?.value.toString();
-        return Object[Symbol.hasInstance].call(this, x);
-      },
-    });
-  }
-
   descriptors["$metadata"] = {
     enumerable: true,
     configurable: true,
diff --git a/src/coalesce-vue/test/api-client.spec.ts b/src/coalesce-vue/test/api-client.spec.ts
index ecdcee7de..f5ba8ed6c 100644
--- a/src/coalesce-vue/test/api-client.spec.ts
+++ b/src/coalesce-vue/test/api-client.spec.ts
@@ -684,7 +684,7 @@ describe("$makeCaller", () => {
     );
 
     const arg = 42;
-    const result = await caller(arg);
+    const result: number = await caller(arg);
     expect(endpointMock.mock.calls[0][0]).toBe(arg);
     expect(caller.result).toBe(arg);
     expect(result).toBe(arg);
@@ -727,15 +727,16 @@ describe("$makeCaller", () => {
     const arg = 42;
     const result = await caller(arg);
 
-    // The typings are actually wrong at the moment - `undefined` is not one of the types of `result`, but it should be.
+    // `result` can be undefined since `undefined` is part of the return signature of the invoker func.
+    const _resultAllowsNumber: typeof result = 24;
+    const _resultAllowsUndefined: typeof result = undefined;
+
     expect(result).toBeUndefined();
 
     expect(endpointMock.mock.calls.length).toBe(0);
     expect(caller.result).toBeNull();
 
     // Typescript typing tests - all of these are valid types of `result`.
-    // Note that Typescript intellisense in VS code seems to be really messed up
-    // right now and shows that `result` is only `string`.:
     caller.result = null;
     caller.result = 13;
 
@@ -759,15 +760,16 @@ describe("$makeCaller", () => {
     const arg = 42;
     const result = await caller(arg);
 
-    // The typings are actually wrong at the moment - `undefined` is not one of the types of `result`, but it should be.
+    // `result` can be undefined since `undefined` is part of the return signature of the invoker func.
+    const _resultAllowsNumber: typeof result = 24;
+    const _resultAllowsUndefined: typeof result = undefined;
+
     expect(result).toBeUndefined();
 
     expect(endpointMock.mock.calls.length).toBe(0);
     expect(caller.result).toBeNull();
 
     // Typescript typing tests - all of these are valid types of `result`.
-    // Note that Typescript intellisense in VS code seems to be really messed up
-    // right now and shows that `result` is only `string`.:
     caller.result = null;
     caller.result = 13;
 
@@ -1437,15 +1439,16 @@ describe("$makeCaller with args object", () => {
     const arg = 42;
     const result = await caller.invokeWithArgs({ num: arg });
 
-    // The typings are actually wrong at the moment - `undefined` is not one of the types of `result`, but it should be.
+    // `result` can be undefined since `undefined` is part of the return signature of the invoker func.
+    const _resultAllowsNumber: typeof result = 24;
+    const _resultAllowsUndefined: typeof result = undefined;
+
     expect(result).toBeUndefined();
 
     expect(endpointMock.mock.calls.length).toBe(0);
     expect(caller.result).toBeNull();
 
     // Typescript typing tests - all of these are valid types of `result`.
-    // Note that Typescript intellisense in VS code seems to be really messed up
-    // right now and shows that `result` is only `string`.:
     caller.result = null;
     caller.result = 13;
 
@@ -1500,6 +1503,15 @@ describe("$makeCaller with args object", () => {
     const _pageSize: number | null = caller.pageSize;
     const _totalCount: number | null = caller.totalCount;
 
+    () => {
+      //@ts-expect-error list should not allow `any[]`
+      caller.rawResponse.data.list = [Symbol()];
+      //@ts-expect-error list should not allow any
+      caller.rawResponse.data.list = Symbol();
+      // Should allow numbers
+      caller.rawResponse.data.list = [42, 67];
+    };
+
     const promiseResult: number[] = await caller(42);
     expect(promiseResult).toStrictEqual([42]);
     expect(caller.result).toStrictEqual([42]);
@@ -1516,11 +1528,28 @@ describe("$makeCaller with args object", () => {
   });
 
   describe.each(["item", "list"] as const)("for %s transport", (type) => {
-    const makeCaller = (
-      endpointMock: ReturnType<
-        typeof makeEndpointMock<number | null | undefined>
-      >,
-    ) =>
+    const makeTransportMock = () =>
+      vitest.fn((arg?: number | null | undefined) =>
+        Promise.resolve({
+          data:
+            type === "list"
+              ? {
+                  wasSuccessful: true,
+                  list: [arg],
+                  page: 1,
+                  pageCount: 1,
+                  pageSize: 10,
+                  totalCount: 1,
+                }
+              : { wasSuccessful: true, object: arg },
+          status: 200,
+          statusText: "OK",
+          headers: {},
+          config: {} as any,
+        }),
+      );
+
+    const makeCaller = (endpointMock: ReturnType<typeof makeTransportMock>) =>
       new PersonApiClient().$makeCaller(
         type,
         (c, num: number) => endpointMock(num),
@@ -1529,7 +1558,7 @@ describe("$makeCaller with args object", () => {
       );
 
     test("uses own args if args not specified", () => {
-      const endpointMock = makeEndpointMock();
+      const endpointMock = makeTransportMock();
       const caller = makeCaller(endpointMock);
 
       caller.args.num = 42;
@@ -1538,7 +1567,7 @@ describe("$makeCaller with args object", () => {
     });
 
     test("own args are reactive", async () => {
-      const endpointMock = makeEndpointMock();
+      const endpointMock = makeTransportMock();
       const caller = makeCaller(endpointMock);
 
       const vue = mountData({ caller });
@@ -1558,7 +1587,7 @@ describe("$makeCaller with args object", () => {
     });
 
     test("uses custom args if specified", () => {
-      const endpointMock = makeEndpointMock();
+      const endpointMock = makeTransportMock();
       const caller = makeCaller(endpointMock);
 
       caller.args.num = 42;
@@ -1569,7 +1598,7 @@ describe("$makeCaller with args object", () => {
     });
 
     test("sets state properties appropriately", async () => {
-      const endpointMock = makeEndpointMock();
+      const endpointMock = makeTransportMock();
       const caller = makeCaller(endpointMock);
 
       caller.args.num = 42;
@@ -1581,7 +1610,7 @@ describe("$makeCaller with args object", () => {
     });
 
     test("debounce ignores redundant requests when resolving", async () => {
-      const endpointMock = makeEndpointMock();
+      const endpointMock = makeTransportMock();
       const caller = new PersonApiClient()
         .$makeCaller(
           type,
@@ -1613,7 +1642,7 @@ describe("$makeCaller with args object", () => {
       expect(endpointMock.mock.calls[1][0]).toBe(3);
 
       await expect(calls[0]).resolves.toBeTruthy();
-      await expect(calls[1]).resolves.toBeFalsy();
+      await expect(calls[1]).resolves.toBeUndefined();
       await expect(calls[2]).resolves.toBeTruthy();
     });
   });
diff --git a/src/coalesce-vue/test/viewmodel.inheritance.spec.ts b/src/coalesce-vue/test/viewmodel.inheritance.spec.ts
index 83f1d89e2..bcc827e2f 100644
--- a/src/coalesce-vue/test/viewmodel.inheritance.spec.ts
+++ b/src/coalesce-vue/test/viewmodel.inheritance.spec.ts
@@ -77,7 +77,7 @@ describe("ViewModel", () => {
   });
 });
 
-describe("abstract proxy", () => {
+describe("abstract loader", () => {
   const expectedData = {
     id: 1,
     discriminator: "discrim1",
@@ -97,81 +97,42 @@ describe("abstract proxy", () => {
     );
   }
 
-  test("class name", async () => {
-    const vm = new AbstractModelViewModel();
-    expect(vm.constructor.name).toBe("AbstractModelViewModelProxy");
-  });
-
-  test("becomes concrete type when loaded with initial data", async () => {
-    const vm = new AbstractModelViewModel(new AbstractImpl1(expectedData));
-
-    expect(vm.$getPropDirty("id")).toBeTruthy();
-    assertIsImpl1(vm);
-  });
-
-  test("can load when ID is provided by initial data", async () => {
-    mockGet();
-
-    const vm = new AbstractModelViewModel({ id: 1 });
-    expect(vm.id).toBe(1);
-    await vm.$load();
-
-    assertIsImpl1(vm);
-    assertLoaded(vm);
-  });
-
-  test("becomes concrete type after $load", async () => {
+  test("load produces concrete ViewModel in result", async () => {
     mockGet();
 
-    const vm = new AbstractModelViewModel();
-    await vm.$load(1);
-
-    assertIsImpl1(vm);
-    assertLoaded(vm);
+    const vm = await AbstractModelViewModel.load(1);
+    assertIsImpl1(vm!);
   });
 
-  test("instanceof is reactive", async () => {
+  test("load caller has standard reactive state", async () => {
     mockGet();
 
-    const vm = new AbstractModelViewModel();
+    const loader = AbstractModelViewModel.load(1);
+    expect(loader.isLoading).toBe(true);
+    expect(loader.wasSuccessful).toBeNull();
+    expect(loader.result).toBeNull();
 
-    // Dummy ref because Vue will always recompute a computed on every access if the computed has no deps.
-    const dummyRef = ref(1);
-
-    const isImpl1 = computed(
-      () => dummyRef.value && vm instanceof AbstractImpl1ViewModel,
-    );
-    expect(isImpl1.value).toBeFalsy();
+    await loader.getPromise();
 
-    await vm.$load(1);
-    expect(isImpl1.value).toBeTruthy();
+    expect(loader.isLoading).toBe(false);
+    expect(loader.wasSuccessful).toBe(true);
+    expect(loader.result).not.toBeNull();
+    assertIsImpl1(loader.result!);
   });
 
-  test("$metadata is reactive", async () => {
+  test("load result is reactive", async () => {
     mockGet();
 
-    const vm = new AbstractModelViewModel();
+    const loader = AbstractModelViewModel.load(1);
 
-    // Dummy ref because Vue will always recompute a computed on every access if the computed has no deps.
     const dummyRef = ref(1);
+    const isLoaded = computed(() => dummyRef.value && loader.result != null);
+    expect(isLoaded.value).toBe(false);
 
-    const isImpl1 = computed(
-      () => dummyRef.value && vm.$metadata.name == "AbstractImpl1",
-    );
-    expect(isImpl1.value).toBeFalsy();
-
-    await vm.$load(1);
-    expect(isImpl1.value).toBeTruthy();
+    await loader.getPromise();
+    expect(isLoaded.value).toBe(true);
   });
 
-  function assertLoaded(vm: AbstractModelViewModel) {
-    expect(vm.$load.wasSuccessful).toBe(true);
-    expect(vm.$load.isLoading).toBe(false);
-    expect(vm.$load.result).toBeInstanceOf(AbstractImpl1);
-    expect(vm.$load.message).toBeFalsy();
-    expect(vm.$load.hasResult).toBeTruthy();
-  }
-
   function assertIsImpl1(vm: AbstractModelViewModel) {
     expect(vm.id).toBe(1);
     expect(vm.discriminator).toBe("discrim1");
@@ -192,5 +153,8 @@ describe("abstract proxy", () => {
 
     const impl1 = vm as AbstractImpl1ViewModel;
     expect(impl1.impl1OnlyField).toBe("foo");
+
+    // Data was loaded clean (not dirty)
+    expect(vm.$getPropDirty("id")).toBe(false);
   }
 });
diff --git a/src/test-targets/viewmodels.g.ts b/src/test-targets/viewmodels.g.ts
index 70cdc4b82..fff62750b 100644
--- a/src/test-targets/viewmodels.g.ts
+++ b/src/test-targets/viewmodels.g.ts
@@ -3,7 +3,7 @@
 import * as $metadata from './metadata.g'
 import * as $models from './models.g'
 import * as $apiClients from './api-clients.g'
-import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractProxyViewModelType } from 'coalesce-vue/lib/viewmodel'
+import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractLoader } from 'coalesce-vue/lib/viewmodel'
 
 export interface AbstractImpl1ViewModel extends $models.AbstractImpl1 {
   impl1OnlyField: string | null;
@@ -143,7 +143,7 @@ export class AbstractImpl2ListViewModel extends ListViewModel<$models.AbstractIm
 
 
 export type AbstractModelViewModel = AbstractImpl1ViewModel | AbstractImpl2ViewModel
-export const AbstractModelViewModel = createAbstractProxyViewModelType<$models.AbstractModel, AbstractModelViewModel>($metadata.AbstractModel, $apiClients.AbstractModelApiClient)
+export const AbstractModelViewModel = createAbstractLoader<AbstractModelViewModel>($apiClients.AbstractModelApiClient, { DataSources: $models.AbstractModel.DataSources })
 
 export class AbstractModelListViewModel extends ListViewModel<$models.AbstractModel, $apiClients.AbstractModelApiClient, AbstractModelViewModel> {
   static DataSources = $models.AbstractModel.DataSources;
diff --git a/templates/Coalesce.Vue.Template/content/Coalesce.Starter.Vue.Web/src/viewmodels.g.ts b/templates/Coalesce.Vue.Template/content/Coalesce.Starter.Vue.Web/src/viewmodels.g.ts
index 7c0e874ec..c2ba0335e 100644
--- a/templates/Coalesce.Vue.Template/content/Coalesce.Starter.Vue.Web/src/viewmodels.g.ts
+++ b/templates/Coalesce.Vue.Template/content/Coalesce.Starter.Vue.Web/src/viewmodels.g.ts
@@ -1,7 +1,7 @@
 import * as $metadata from './metadata.g'
 import * as $models from './models.g'
 import * as $apiClients from './api-clients.g'
-import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractProxyViewModelType } from 'coalesce-vue/lib/viewmodel'
+import { ViewModel, ListViewModel, ViewModelCollection, ServiceViewModel, type DeepPartial, defineProps, createAbstractLoader } from 'coalesce-vue/lib/viewmodel'
 
 export interface AuditLogViewModel extends $models.AuditLog {
   userId: string | null;