@warp-drive/legacy 5.8.0-alpha.15 → 5.8.0-alpha.17

package/declarations/index.d.ts

@@ -6,8 +6,12 @@ import { Store, type StoreSetupOptions } from "@warp-drive/core";
 import type { ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
 interface _LegacyStoreSetupOptions extends Omit<StoreSetupOptions, "schemas"> {
 	schemas?: Array<ResourceSchema | ObjectSchema>;
+	/**
+	* Whether to include support for ModelFragments migrations.
+	*/
+	modelFragments?: boolean;
 }
-interface LegacyModelStoreSetupOptions extends _LegacyStoreSetupOptions {
+export interface LegacyModelStoreSetupOptions extends _LegacyStoreSetupOptions {
 	/**
 	* If true, it is presumed that no requests require use of the LegacyNetworkHandler
 	* and associated adapters/serializer methods.
@@ -19,7 +23,7 @@ interface LegacyModelStoreSetupOptions extends _LegacyStoreSetupOptions {
 	*/
 	legacyRequests?: false;
 }
-interface LegacyModelAndNetworkStoreSetupOptions extends _LegacyStoreSetupOptions {
+export interface LegacyModelAndNetworkStoreSetupOptions extends _LegacyStoreSetupOptions {
 	/**
 	* If true, it is presumed that no requests require use of the LegacyNetworkHandler
 	* and associated adapters/serializer methods.
@@ -31,7 +35,7 @@ interface LegacyModelAndNetworkStoreSetupOptions extends _LegacyStoreSetupOption
 	*/
 	legacyRequests?: false;
 }
-interface LegacyModelAndNetworkAndRequestStoreSetupOptions extends _LegacyStoreSetupOptions {
+export interface LegacyModelAndNetworkAndRequestStoreSetupOptions extends _LegacyStoreSetupOptions {
 	/**
 	* If true, it is presumed that no requests require use of the LegacyNetworkHandler
 	* and associated adapters/serializer methods.

package/declarations/model/migration-support.d.ts

@@ -243,6 +243,10 @@ export declare class DelegatingSchemaService implements SchemaService {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
+	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
+		kind: "object" | "array";
+		name: string;
+	}): boolean;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
 	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;

package/declarations/model-fragments/extensions/fragment-array.d.ts

@@ -0,0 +1,16 @@
+import type { Fragment } from "./fragment.js";
+export declare class FragmentArray<T extends Fragment> {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	addFragment(fragment?: T): Fragment[] | undefined;
+	createFragment(fragment?: T): Fragment | undefined;
+	removeFragment(fragment?: T): void;
+	rollbackAttributes(): void;
+}
+export declare const FragmentArrayExtension: {
+	kind: "array";
+	name: "fragment-array";
+	features: typeof FragmentArray;
+};
+export default FragmentArrayExtension;

package/declarations/model-fragments/extensions/fragment.d.ts

@@ -0,0 +1,15 @@
+import type { PrivateReactiveResource } from "@warp-drive/core/reactive/-private";
+export declare class Fragment {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	get isFragment(): boolean;
+	get $type(): string | null | undefined;
+	rollbackAttributes(this: PrivateReactiveResource): void;
+}
+export declare const FragmentExtension: {
+	kind: "object";
+	name: "fragment";
+	features: typeof Fragment;
+};
+export default FragmentExtension;

package/declarations/model-fragments/hooks/model-for.d.ts

@@ -0,0 +1,20 @@
+import type { Store } from "@warp-drive/core";
+import type { ModelSchema } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
+	__store: Store;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+	get fields(): Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+	get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}
+export declare function fragmentsModelFor<T extends TypedRecordInstance>(this: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare const modelFor: typeof fragmentsModelFor;
+export {};

package/declarations/model-fragments/index.d.ts

@@ -0,0 +1,5 @@
+import type { WithArrayLike, WithEmberObject } from "../compat/extensions.js";
+import type { Fragment } from "./extensions/fragment.js";
+import type { FragmentArray } from "./extensions/fragment-array.js";
+export type WithFragment<T> = T & WithEmberObject<T> & Fragment;
+export type WithFragmentArray<T extends Fragment> = T & WithArrayLike<T> & FragmentArray<T>;

package/declarations/model-fragments/instance-initializers/fragment-extensions.d.ts

@@ -0,0 +1,9 @@
+import type ApplicationInstance from "@ember/application/instance";
+import type { SchemaService } from "@warp-drive/core/types";
+export declare function registerFragmentExtensions(schema: SchemaService): void;
+export declare function initialize(application: ApplicationInstance): void;
+declare const _default: {
+	name: string;
+	initialize: (application: ApplicationInstance) => void;
+};
+export default _default;

package/declarations/model-fragments/utilities/with-array-defaults.d.ts

@@ -0,0 +1,15 @@
+/**
+* Used as a helper to setup the relevant parts of an array
+* schema and add extensions etc.
+*
+* @param arrayName The name of the array
+* @returns The schema for an array
+*/
+export declare function withArrayDefaults<ArrayName extends string>(arrayName: ArrayName): {
+	kind: "array";
+	name: ArrayName;
+	type: `array:${string}`;
+	options: {
+		arrayExtensions: string[];
+	};
+};

package/declarations/model-fragments/utilities/with-fragment-array-defaults.d.ts

@@ -0,0 +1,20 @@
+/**
+* Used as a helper to setup the relevant parts of a fragment-array
+* schema and add extensions etc.
+*
+* @param fragmentArrayType The type of the fragment-array
+* @param fragmentArrayName The name of the fragment-array
+* @returns The schema for a fragment-array
+*/
+export declare function withFragmentArrayDefaults<
+	FragmentArrayType extends string,
+	FragmentArrayName extends string
+>(fragmentArrayType: FragmentArrayType, fragmentArrayName?: FragmentArrayName): {
+	kind: "schema-array";
+	type: `fragment:${string}`;
+	name: string;
+	options: {
+		arrayExtensions: string[];
+		defaultValue: boolean;
+	};
+};

package/declarations/model-fragments/utilities/with-fragment-defaults.d.ts

@@ -0,0 +1,19 @@
+/**
+* Used as a helper to setup the relevant parts of a fragment schema
+* and add extensions etc.
+*
+* @param fragmentType The type of the fragment
+* @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
+* @returns The schema for a fragment
+*/
+export declare function withFragmentDefaults<
+	FragmentType extends string,
+	FragmentName extends string
+>(fragmentType: FragmentType, fragmentName?: FragmentName): {
+	kind: "schema-object";
+	type: `fragment:${FragmentType}`;
+	name: FragmentType | FragmentName;
+	options: {
+		objectExtensions: string[];
+	};
+};

package/declarations/model-fragments/utilities/with-legacy.d.ts

@@ -0,0 +1,3 @@
+import type { LegacyResourceSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { WithPartial } from "@warp-drive/core/types/utils";
+export declare function withLegacy(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): ResourceSchema;

package/declarations/model-fragments.d.ts

@@ -0,0 +1,9 @@
+export { withArrayDefaults } from "./model-fragments/utilities/with-array-defaults.js";
+export { withFragmentDefaults } from "./model-fragments/utilities/with-fragment-defaults.js";
+export { withFragmentArrayDefaults } from "./model-fragments/utilities/with-fragment-array-defaults.js";
+export { withLegacy } from "./model-fragments/utilities/with-legacy.js";
+export { registerFragmentExtensions } from "./model-fragments/instance-initializers/fragment-extensions.js";
+export { modelFor } from "./model-fragments/hooks/model-for.js";
+export { FragmentArray, FragmentArrayExtension } from "./model-fragments/extensions/fragment-array.js";
+export { Fragment, FragmentExtension } from "./model-fragments/extensions/fragment.js";
+export type { WithFragment, WithFragmentArray } from "./model-fragments/index.js";

package/dist/index.js

@@ -13,6 +13,7 @@ import "./errors-COviC59J.js";
 import "./schema-provider-JlCneqZH.js";
 import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-Bp8SIQBU.js";
 import { registerDerivations as registerDerivations$1, DelegatingSchemaService } from './model/migration-support.js';
+import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-B0TSd9HU.js";
 import { restoreDeprecatedStoreBehaviors } from './store.js';
 
 /**
@@ -29,7 +30,9 @@ function useLegacyStore(options, StoreKlass = Store) {
       throw new Error(`If legacyRequests is true, linksMode must be false`);
     }
   })(!(options.linksMode && options.legacyRequests)) : {};
-  class LegacyConfiguredStore extends StoreKlass {
+  // we extend the store to ensure we don't leak our prototype overrides to other stores below.
+  class BaseKlass extends StoreKlass {}
+  class LegacyConfiguredStore extends BaseKlass {
     requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...(options.handlers ?? []), Fetch].filter(Boolean)).useCache(CacheHandler);
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
@@ -82,6 +85,12 @@ function useLegacyStore(options, StoreKlass = Store) {
       schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectArrayExtension);
       schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectExtension);
 
+      // add support for fragments
+      if (options.modelFragments) {
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
+        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
+      }
+
       // Add fallback for Models
       return new DelegatingSchemaService(this, schema);
     }
@@ -104,14 +113,25 @@ function useLegacyStore(options, StoreKlass = Store) {
     }
     modelFor(type) {
       assertType(this.schema, type);
+      // TODO I'm not sure this is right
       macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
         if (!test) {
-          throw new Error(`modelFor should only be used to lookup legacy models when in linksMode`);
+          throw new Error(`modelFor should only be used to lookup legacy models when in linksMode: false`);
         }
-      })(!options.linksMode || this.schema.isDelegated({
+      })(!options.linksMode || !this.schema.isDelegated({
         type
       })) : {};
-      return modelFor.call(this, type) || super.modelFor(type);
+      const klass =
+      // prefer real models if present
+      modelFor.call(this, type) || (
+      // fallback to ShimModelClass specific to fragments if fragments support in use
+      options.modelFragments ? fragmentsModelFor.call(this, type) : false) ||
+      // fallback to ShimModelClass
+      super.modelFor(type);
+
+      // eslint-disable-next-line no-console
+      console.log(`model for ${type}`, klass);
+      return klass;
     }
     adapterFor(modelName, _allowMissing) {
       macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -162,7 +182,7 @@ function useLegacyStore(options, StoreKlass = Store) {
     }
   }
   if (options.legacyRequests) {
-    restoreDeprecatedStoreBehaviors(LegacyConfiguredStore);
+    restoreDeprecatedStoreBehaviors(BaseKlass);
   }
   return LegacyConfiguredStore;
 }

package/dist/model/migration-support.js

@@ -484,6 +484,9 @@ class DelegatingSchemaService {
   registerHashFn(hashFn) {
     this._preferred.registerHashFn(hashFn);
   }
+  CAUTION_MEGA_DANGER_ZONE_hasExtension(ext) {
+    return this._preferred.CAUTION_MEGA_DANGER_ZONE_hasExtension(ext);
+  }
   CAUTION_MEGA_DANGER_ZONE_registerExtension(extension) {
     this._preferred.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
   }

package/dist/model-for-B0TSd9HU.js

@@ -0,0 +1,221 @@
+import { tracked, cached } from '@glimmer/tracking';
+import { Context } from '@warp-drive/core/reactive/-private';
+import { a as decorateFieldV2, i as initializeDeferredDecorator, d as decorateMethodV2 } from "./runtime-BPCpkOf1-BKOwiRJp.js";
+class Fragment {
+  static {
+    decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  static {
+    decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  get hasDirtyAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    return false;
+  }
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
+  }
+  get isFragment() {
+    return true;
+  }
+  get $type() {
+    const {
+      field
+    } = this[Context];
+    return field?.type;
+  }
+  rollbackAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    if (path) {
+      const oldValue = store.cache.getRemoteAttr(resourceKey, path);
+      store.cache.setAttr(resourceKey, path, oldValue);
+    }
+  }
+}
+const FragmentExtension = {
+  kind: 'object',
+  name: 'fragment',
+  features: Fragment
+};
+class FragmentArray {
+  static {
+    decorateFieldV2(this.prototype, "isDestroying", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroying = (initializeDeferredDecorator(this, "isDestroying"), void 0); // We might want to check the parent values once we move this code to warp-drive.
+  static {
+    decorateFieldV2(this.prototype, "isDestroyed", [tracked], function () {
+      return false;
+    });
+  }
+  #isDestroyed = (initializeDeferredDecorator(this, "isDestroyed"), void 0);
+  get hasDirtyAttributes() {
+    const {
+      path,
+      resourceKey,
+      store
+    } = this[Context];
+    const record = store.peekRecord(resourceKey);
+    if (record.hasDirtyAttributes && path) {
+      const root = path.at(0);
+      return root in record.changedAttributes();
+    }
+    return false;
+  }
+  static {
+    decorateMethodV2(this.prototype, "hasDirtyAttributes", [cached]);
+  }
+  addFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    return this.addObject(fragment);
+  }
+  createFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    return this.pushObject(fragment);
+  }
+  removeFragment(fragment) {
+    if (!fragment) {
+      return;
+    }
+    const index = this.indexOf(fragment);
+    if (index !== -1) {
+      this.splice(index, 1);
+    }
+  }
+  rollbackAttributes() {
+    for (const fragment of this) {
+      // @ts-expect-error TODO: fix these types
+      fragment?.rollbackAttributes?.();
+    }
+  }
+}
+const FragmentArrayExtension = {
+  kind: 'array',
+  name: 'fragment-array',
+  features: FragmentArray
+};
+
+// if modelFor turns out to be a bottleneck we should replace with a Map
+// and clear it during store teardown.
+const AvailableShims = new WeakMap();
+function getShimClass(store, modelName) {
+  let shims = AvailableShims.get(store);
+  if (!shims) {
+    shims = Object.create(null);
+    AvailableShims.set(store, shims);
+  }
+  let shim = shims[modelName];
+  if (shim === undefined) {
+    shim = shims[modelName] = new ShimModelClass(store, modelName);
+  }
+  return shim;
+}
+const AttributeKinds = ['field', 'attribute', 'object', 'array', 'schema-object', 'schema-array'];
+
+// Mimics the static apis of @ember-data/model
+class ShimModelClass {
+  constructor(store, modelName) {
+    this.__store = store;
+    this.modelName = modelName;
+  }
+  get fields() {
+    const fields = new Map();
+    const fieldSchemas = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fieldSchemas.forEach((schema, key) => {
+      // @ts-expect-error checking if a string is a valid string
+      if (AttributeKinds.includes(schema.kind)) {
+        fields.set(key, 'attribute');
+      } else if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        fields.set(key, schema.kind);
+      }
+    });
+    return fields;
+  }
+  get attributes() {
+    const attrs = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        attrs.set(key, schema);
+        // @ts-expect-error checking if a string is a valid string
+      } else if (AttributeKinds.includes(schema.kind)) {
+        attrs.set(key, {
+          kind: 'attribute',
+          name: key,
+          type: null,
+          options: schema.options ?? {}
+        });
+      }
+    });
+    return attrs;
+  }
+  get relationshipsByName() {
+    const rels = new Map();
+    const fields = this.__store.schema.fields({
+      type: this.modelName
+    });
+    fields.forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        rels.set(key, schema);
+      }
+    });
+    return rels;
+  }
+  eachAttribute(callback, binding) {
+    this.attributes.forEach((schema, key) => {
+      callback.call(binding, key, schema);
+    });
+  }
+  eachRelationship(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'belongsTo' || schema.kind === 'hasMany') {
+        callback.call(binding, key, schema);
+      }
+    });
+  }
+  eachTransformedAttribute(callback, binding) {
+    this.__store.schema.fields({
+      type: this.modelName
+    }).forEach((schema, key) => {
+      if (schema.kind === 'attribute') {
+        const type = schema.type;
+        if (type) callback.call(binding, key, type);
+      }
+    });
+  }
+}
+function fragmentsModelFor(modelName) {
+  return getShimClass(this, modelName);
+}
+const modelFor = fragmentsModelFor;
+export { FragmentExtension as F, FragmentArrayExtension as a, FragmentArray as b, Fragment as c, fragmentsModelFor as f, modelFor as m };

package/dist/model-fragments.js

@@ -0,0 +1,76 @@
+import { singularize, pluralize } from '@warp-drive/utilities/string';
+import { withDefaults } from './model/migration-support.js';
+import { F as FragmentExtension, a as FragmentArrayExtension } from "./model-for-B0TSd9HU.js";
+export { c as Fragment, b as FragmentArray, m as modelFor } from "./model-for-B0TSd9HU.js";
+
+/**
+ * Used as a helper to setup the relevant parts of an array
+ * schema and add extensions etc.
+ *
+ * @param arrayName The name of the array
+ * @returns The schema for an array
+ */
+function withArrayDefaults(arrayName) {
+  return {
+    kind: 'array',
+    name: arrayName,
+    type: `array:${singularize(arrayName)}`,
+    options: {
+      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array']
+    }
+  };
+}
+
+/**
+ * Used as a helper to setup the relevant parts of a fragment schema
+ * and add extensions etc.
+ *
+ * @param fragmentType The type of the fragment
+ * @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
+ * @returns The schema for a fragment
+ */
+function withFragmentDefaults(fragmentType, fragmentName) {
+  return {
+    kind: 'schema-object',
+    type: `fragment:${fragmentType}`,
+    name: fragmentName ?? fragmentType,
+    options: {
+      objectExtensions: ['ember-object', 'fragment']
+    }
+  };
+}
+
+/**
+ * Used as a helper to setup the relevant parts of a fragment-array
+ * schema and add extensions etc.
+ *
+ * @param fragmentArrayType The type of the fragment-array
+ * @param fragmentArrayName The name of the fragment-array
+ * @returns The schema for a fragment-array
+ */
+function withFragmentArrayDefaults(fragmentArrayType, fragmentArrayName) {
+  return {
+    kind: 'schema-array',
+    type: `fragment:${singularize(fragmentArrayType)}`,
+    name: fragmentArrayName ?? pluralize(fragmentArrayType),
+    options: {
+      arrayExtensions: ['ember-object', 'ember-array-like', 'fragment-array'],
+      defaultValue: true
+    }
+  };
+}
+function withLegacy(schema) {
+  return withDefaults({
+    ...schema,
+    identity: {
+      kind: '@id',
+      name: 'id'
+    },
+    objectExtensions: ['ember-object', 'fragment']
+  });
+}
+function registerFragmentExtensions(schema) {
+  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
+  schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
+}
+export { FragmentArrayExtension, FragmentExtension, registerFragmentExtensions, withArrayDefaults, withFragmentArrayDefaults, withFragmentDefaults, withLegacy };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warp-drive/legacy",
-  "version": "5.8.0-alpha.15",
+  "version": "5.8.0-alpha.17",
   "description": "Decommissioned Packages for WarpDrive | Things your app might still want to maintain use of for a little longer.",
   "keywords": [
     "ember-addon"
@@ -32,8 +32,8 @@
     }
   },
   "peerDependencies": {
-    "@warp-drive/core": "5.8.0-alpha.15",
-    "@warp-drive/utilities": "5.8.0-alpha.15"
+    "@warp-drive/core": "5.8.0-alpha.17",
+    "@warp-drive/utilities": "5.8.0-alpha.17"
   },
   "dependencies": {
     "@embroider/macros": "^1.18.1"
@@ -43,9 +43,9 @@
     "@babel/plugin-transform-typescript": "^7.28.0",
     "@babel/preset-typescript": "^7.27.1",
     "@types/jquery": "^3.5.33",
-    "@warp-drive/internal-config": "5.8.0-alpha.15",
-    "@warp-drive/core": "5.8.0-alpha.15",
-    "@warp-drive/utilities": "5.8.0-alpha.15",
+    "@warp-drive/internal-config": "5.8.0-alpha.17",
+    "@warp-drive/core": "5.8.0-alpha.17",
+    "@warp-drive/utilities": "5.8.0-alpha.17",
     "ember-source": "~6.6.0",
     "decorator-transforms": "^2.3.0",
     "expect-type": "^1.2.2",