@warp-drive/core 5.9.0-alpha.18 → 5.9.0-alpha.19

package/dist/unpkg/dev-deprecated/{index-CDjd631s.js → index-BYFUHVPd.js}

@@ -8326,6 +8326,9 @@ class ReactiveResource {
         if (prop === Destroy || prop === Checkout) {
           return true;
         }
+        if (prop === identityField?.name) {
+          return true;
+        }
         return fields.has(prop);
       },
       getOwnPropertyDescriptor(target, prop) {
@@ -9076,6 +9079,90 @@ function registerDerivations(schema) {
   schema.registerDerivation(fromIdentity);
   schema.registerDerivation(_constructor);
 }
+
+/**
+ * A relationship field capable of declaring `options.as`, marking it as a
+ * concrete implementation of an abstract polymorphic type.
+ */
+
+/**
+ * A relationship field contributed to an abstract type's schema, along with
+ * the name of the type that contributed it (either a concrete implementer,
+ * via `options.as`, or the abstract type's own schema), for use in assertion
+ * messages when two contributions disagree on shape.
+ */
+
+/**
+ * Reduces a field to a plain object with a fixed key order, covering every
+ * option any relationship-implementer field can declare, so two fields can
+ * be compared for exact equality via `JSON.stringify` regardless of the key
+ * order the schema author happened to write them in.
+ *
+ * `options.as` is included and is *not* special-cased: every contributor to
+ * a given field name on an abstract type - including the abstract type's
+ * own schema, if it has one - is expected to declare `as` equal to that
+ * abstract type's own name. This is redundant/self-referential for the
+ * abstract type's own schema, but required for consistency: relationship
+ * resolution elsewhere (e.g. `inverse` name-matching) does not itself
+ * validate `as`, so a field with a missing or incorrect `as` can otherwise
+ * be silently pulled into a relationship it never declared it implements.
+ */
+function comparableAbstractFieldShape(field) {
+  const {
+    kind,
+    name,
+    type,
+    sourceKey,
+    options
+  } = field;
+  return {
+    kind,
+    name,
+    type,
+    sourceKey,
+    options: {
+      as: options?.as,
+      async: options?.async,
+      inverse: options?.inverse,
+      polymorphic: options?.polymorphic,
+      linksMode: options?.linksMode,
+      resetOnRemoteUpdate: options?.resetOnRemoteUpdate,
+      arrayExtensions: options?.arrayExtensions
+    }
+  };
+}
+
+/**
+ * Asserts that two contributions to the same field name on an abstract
+ * polymorphic type - whether from two different concrete implementers, or
+ * from an implementer and the abstract type's own schema - declare an
+ * identical shape: `kind`, `type`, and every option, including `as` (which
+ * every contributor, the abstract type's own schema included, must declare
+ * equal to `abstractType`). A mismatch here (e.g. one implementer's field
+ * being a `hasMany` while another's is a `belongsTo`, the two disagreeing on
+ * `inverse`/`async`/`polymorphic`, or one omitting or misdeclaring `as`)
+ * cannot be resolved by picking one side arbitrarily, since that would
+ * silently leave whichever side lost the mismatch pointing at a relationship
+ * whose true shape differs from what its own schema declared.
+ */
+function assertConsistentAbstractFieldShape(abstractType, fieldName, existing, incoming) {
+  // This function exists solely to support the `assert()` call below - there
+  // is no other work here with an effect in production. Since `assert()`'s
+  // own babel-macro stripping only removes the call expression itself, not
+  // the (comparatively expensive, involving `JSON.stringify`) computation of
+  // its arguments, guard the whole body so none of it survives in production
+  // builds, matching how `assertPolymorphicType`/`assertInheritedSchema` and
+  // their call sites are gated in `assert-polymorphic-type.ts`.
+  {
+    const existingShape = comparableAbstractFieldShape(existing.field);
+    const incomingShape = comparableAbstractFieldShape(incoming.field);
+    (test => {
+      if (!test) {
+        throw new Error(`Expected the relationship '${fieldName}' on the abstract polymorphic type '${abstractType}' to be declared identically everywhere it is implemented (including 'options.as', which every contributor - the abstract type's own schema included - must declare equal to '${abstractType}'), but '${existing.source}' declares it as:\n\n${JSON.stringify(existingShape, null, 2)}\n\nwhile '${incoming.source}' declares it as:\n\n${JSON.stringify(incomingShape, null, 2)}\n\nAll concrete implementers of an abstract type - and the abstract type's own schema, if it has one - must declare an identical shape for any relationship field they share.`);
+      }
+    })(JSON.stringify(existingShape) === JSON.stringify(incomingShape));
+  }
+}
 /**
  * Wraps a derivation in a new function with Derivation signature but that looks
  * up the value in the cache before recomputing.
@@ -9115,6 +9202,18 @@ class SchemaService {
 
   /** @internal */
 
+  /**
+   * Tracks, per abstract type, the relationship fields that concrete
+   * implementers have contributed via `options.as`, along with the type
+   * that contributed each one (for assertion messages). This is
+   * independent of whatever schema (synthesized or user-registered)
+   * currently occupies `_schemas` for that type, so that these fields
+   * survive regardless of the order in which the abstract type's
+   * implementers and its own (optional) concrete schema are registered.
+   *
+   * @internal
+   */
+
   /** @internal */
 
   /** @internal */
@@ -9126,6 +9225,7 @@ class SchemaService {
     this._derivations = new Map();
     this._traits = new Map();
     this._modes = new Map();
+    this._abstractImplementerFields = new Map();
     this._extensions = {
       object: new Map(),
       array: new Map()
@@ -9221,6 +9321,7 @@ class SchemaService {
     const fields = new Map();
     const relationships = {};
     const attributes = {};
+    const abstractImplementations = [];
     for (const field of schema.fields) {
       (test => {
         if (!test) {
@@ -9234,6 +9335,31 @@ class SchemaService {
         attributes[field.name] = field;
       } else if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
         relationships[field.name] = field;
+        if (field.options?.as) {
+          abstractImplementations.push(field);
+        }
+      }
+    }
+
+    // This type may already be known as an abstract polymorphic type,
+    // implemented by other concrete types via `options.as`, from before it
+    // ever had a schema of its own (see `_registerAbstractTypeImplementation`).
+    // Carry those previously-contributed fields forward so that registering
+    // a "real" schema for the type - whenever that happens to occur - never
+    // erases the relationships its implementers depend on.
+    const implementerFields = this._abstractImplementerFields.get(schema.type);
+    if (implementerFields) {
+      for (const [name, contribution] of implementerFields) {
+        const ownField = fields.get(name);
+        if (!ownField) {
+          fields.set(name, contribution.field);
+          relationships[name] = contribution.field;
+        } else {
+          assertConsistentAbstractFieldShape(schema.type, name, contribution, {
+            field: ownField,
+            source: schema.type
+          });
+        }
       }
     }
     const cacheFields = null;
@@ -9252,6 +9378,101 @@ class SchemaService {
       internalSchema.cacheFields = getCacheFields(internalSchema);
     }
     this._schemas.set(schema.type, internalSchema);
+
+    // A relationship field's `as` option marks it as a valid concrete
+    // implementer of an abstract polymorphic type (e.g. `as: 'commentable'`).
+    // That abstract type may never be given its own schema by the user - it
+    // may exist only to be implemented by concrete types like this one - or
+    // it may already have (or later receive) a schema of its own, e.g. if it
+    // turns out to also be a real, directly-resolvable resource. Either way,
+    // ensure it has a schema with this field present, so that it behaves
+    // like any other registered resource (`hasResource`, `fields`, etc.)
+    // instead of requiring special-casing wherever abstract relationship
+    // types are resolved.
+    for (const field of abstractImplementations) {
+      this._registerAbstractTypeImplementation(field, schema.type);
+    }
+  }
+
+  /** @internal */
+  _registerAbstractTypeImplementation(field, implementer) {
+    const abstractType = field.options.as;
+    let implementerFields = this._abstractImplementerFields.get(abstractType);
+    if (!implementerFields) {
+      implementerFields = new Map();
+      this._abstractImplementerFields.set(abstractType, implementerFields);
+    }
+
+    // Unlike the original approach this replaced, `as` is *not* stripped here:
+    // the field as synthesized onto the abstract type's own schema keeps
+    // `options.as === abstractType`, redundant/self-referential as that is.
+    // This keeps every contributor - implementers and the abstract type's
+    // own schema alike - declaring the same thing, which is what
+    // `assertConsistentAbstractFieldShape` checks, and it is also what lets
+    // `assertPolymorphicType` (which reads a field's declared `as` off
+    // whatever `schema.fields()` serves for its type) correctly permit the
+    // abstract type itself to be pushed directly into this relationship.
+    const abstractField = {
+      ...field
+    };
+    const contribution = {
+      field: abstractField,
+      source: implementer
+    };
+
+    // all concrete implementations of an abstract type are required to
+    // share the same shape for the field that implements it, so the first
+    // one registered is as good a canonical source as any - but a later,
+    // differently-shaped one is almost certainly a mistake rather than an
+    // intentional override, so we catch it rather than silently ignoring it.
+    const existingImplementer = implementerFields.get(field.name);
+    if (existingImplementer) {
+      {
+        assertConsistentAbstractFieldShape(abstractType, field.name, existingImplementer, contribution);
+      }
+      return;
+    }
+    implementerFields.set(field.name, contribution);
+    let abstractSchema = this._schemas.get(abstractType);
+    if (!abstractSchema) {
+      abstractSchema = {
+        original: {
+          legacy: true,
+          identity: {
+            kind: '@id',
+            name: 'id'
+          },
+          type: abstractType,
+          fields: []
+        },
+        finalized: true,
+        fields: new Map(),
+        cacheFields: new Map(),
+        relationships: {},
+        attributes: {},
+        traits: new Set()
+      };
+      this._schemas.set(abstractType, abstractSchema);
+    }
+    const existingAbstractField = abstractSchema.fields.get(field.name);
+    if (existingAbstractField) {
+      {
+        assertConsistentAbstractFieldShape(abstractType, field.name, {
+          field: existingAbstractField,
+          source: abstractType
+        }, contribution);
+      }
+      return;
+    }
+    abstractSchema.fields.set(field.name, abstractField);
+    abstractSchema.relationships[field.name] = abstractField;
+
+    // If the schema is mid-finalization (traits pending), finalizeResource
+    // will recompute cacheFields from the current `fields` map anyway; avoid
+    // doing so prematurely from a partially-resolved set of fields.
+    if (abstractSchema.finalized) {
+      abstractSchema.cacheFields = getCacheFields(abstractSchema);
+    }
   }
 
   /**
@@ -10044,7 +10265,29 @@ globalThis.setWarpDriveIsMaybeMirage = setIsMaybeMirage;
  */
 function useRecommendedStore(options, StoreKlass = Store) {
   return class AppStore extends StoreKlass {
-    requestManager = new RequestManager().use([...(options.handlers ?? []), Fetch]).useCache(CacheHandler);
+    constructor(createArgs) {
+      super(createArgs);
+      // installed via defineProperty (rather than a class field/accessor) so that
+      // this lazy override of the inherited `requestManager` field does not
+      // conflict with the documented pattern of assigning it directly on
+      // consumer-authored Store subclasses. The setter preserves the ability
+      // to replace `requestManager` outright after construction.
+      let requestManager;
+      Object.defineProperty(this, 'requestManager', {
+        configurable: true,
+        enumerable: true,
+        get: () => {
+          if (!requestManager) {
+            const handlers = typeof options.handlers === 'function' ? options.handlers(this) : options.handlers ?? [];
+            requestManager = new RequestManager().use([...handlers, Fetch]).useCache(CacheHandler);
+          }
+          return requestManager;
+        },
+        set: value => {
+          requestManager = value;
+        }
+      });
+    }
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
       // 15 minutes

package/dist/unpkg/dev-deprecated/index.js

@@ -1,4 +1,4 @@
-export { C as CacheHandler, F as Fetch, z as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, E as setIdentifierForgetMethod, B as setIdentifierGenerationMethod, G as setIdentifierResetMethod, D as setIdentifierUpdateMethod, H as setKeyInfoForResource, s as storeFor, A as useRecommendedStore } from "./index-CDjd631s.js";
+export { C as CacheHandler, F as Fetch, z as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, E as setIdentifierForgetMethod, B as setIdentifierGenerationMethod, G as setIdentifierResetMethod, D as setIdentifierUpdateMethod, H as setKeyInfoForResource, s as storeFor, A as useRecommendedStore } from "./index-BYFUHVPd.js";
 import "./-private-3C1OkYtZ.js";
 import "./-leaked-C40gfiH-.js";
 import './store.js';

package/dist/unpkg/dev-deprecated/reactive.js

@@ -1,3 +1,3 @@
-export { u as SchemaService, p as checkout, y as commit, v as fromIdentity, q as instantiateRecord, x as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-CDjd631s.js";
+export { u as SchemaService, p as checkout, y as commit, v as fromIdentity, q as instantiateRecord, x as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-BYFUHVPd.js";
 export { C as Checkout } from "./-private-3C1OkYtZ.js";
 export { c as createRequestSubscription, a as getPromiseState, g as getRequestState } from "./-leaked-C40gfiH-.js";

package/dist/unpkg/dev-deprecated/store/-private.js

@@ -1 +1 @@
-export { C as CacheHandler, R as RecordArrayManager, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, l as createLegacyManyArray, e as ensureStringId, f as fastPush, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, r as recordIdentifierFor, j as setRecordIdentifier, s as storeFor } from "../index-CDjd631s.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, l as createLegacyManyArray, e as ensureStringId, f as fastPush, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, r as recordIdentifierFor, j as setRecordIdentifier, s as storeFor } from "../index-BYFUHVPd.js";

package/dist/unpkg/dev-deprecated/types/-private.js

@@ -1,5 +1,5 @@
 const name = "@warp-drive/core";
-const version = "5.9.0-alpha.18";
+const version = "5.9.0-alpha.19";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import

package/dist/unpkg/prod/{index-BMBm3kYx.js → index-C-AhVafS.js}

@@ -5947,6 +5947,9 @@ class ReactiveResource {
         if (prop === Destroy || prop === Checkout) {
           return true;
         }
+        if (prop === identityField?.name) {
+          return true;
+        }
         return fields.has(prop);
       },
       getOwnPropertyDescriptor(target, prop) {
@@ -6643,6 +6646,18 @@ class SchemaService {
 
   /** @internal */
 
+  /**
+   * Tracks, per abstract type, the relationship fields that concrete
+   * implementers have contributed via `options.as`, along with the type
+   * that contributed each one (for assertion messages). This is
+   * independent of whatever schema (synthesized or user-registered)
+   * currently occupies `_schemas` for that type, so that these fields
+   * survive regardless of the order in which the abstract type's
+   * implementers and its own (optional) concrete schema are registered.
+   *
+   * @internal
+   */
+
   /** @internal */
 
   /** @internal */
@@ -6654,6 +6669,7 @@ class SchemaService {
     this._derivations = new Map();
     this._traits = new Map();
     this._modes = new Map();
+    this._abstractImplementerFields = new Map();
     this._extensions = {
       object: new Map(),
       array: new Map()
@@ -6699,12 +6715,33 @@ class SchemaService {
     const fields = new Map();
     const relationships = {};
     const attributes = {};
+    const abstractImplementations = [];
     for (const field of schema.fields) {
       fields.set(field.name, field);
       if (field.kind === 'attribute') {
         attributes[field.name] = field;
       } else if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
         relationships[field.name] = field;
+        if (field.options?.as) {
+          abstractImplementations.push(field);
+        }
+      }
+    }
+
+    // This type may already be known as an abstract polymorphic type,
+    // implemented by other concrete types via `options.as`, from before it
+    // ever had a schema of its own (see `_registerAbstractTypeImplementation`).
+    // Carry those previously-contributed fields forward so that registering
+    // a "real" schema for the type - whenever that happens to occur - never
+    // erases the relationships its implementers depend on.
+    const implementerFields = this._abstractImplementerFields.get(schema.type);
+    if (implementerFields) {
+      for (const [name, contribution] of implementerFields) {
+        const ownField = fields.get(name);
+        if (!ownField) {
+          fields.set(name, contribution.field);
+          relationships[name] = contribution.field;
+        }
       }
     }
     const cacheFields = null;
@@ -6723,6 +6760,92 @@ class SchemaService {
       internalSchema.cacheFields = getCacheFields(internalSchema);
     }
     this._schemas.set(schema.type, internalSchema);
+
+    // A relationship field's `as` option marks it as a valid concrete
+    // implementer of an abstract polymorphic type (e.g. `as: 'commentable'`).
+    // That abstract type may never be given its own schema by the user - it
+    // may exist only to be implemented by concrete types like this one - or
+    // it may already have (or later receive) a schema of its own, e.g. if it
+    // turns out to also be a real, directly-resolvable resource. Either way,
+    // ensure it has a schema with this field present, so that it behaves
+    // like any other registered resource (`hasResource`, `fields`, etc.)
+    // instead of requiring special-casing wherever abstract relationship
+    // types are resolved.
+    for (const field of abstractImplementations) {
+      this._registerAbstractTypeImplementation(field, schema.type);
+    }
+  }
+
+  /** @internal */
+  _registerAbstractTypeImplementation(field, implementer) {
+    const abstractType = field.options.as;
+    let implementerFields = this._abstractImplementerFields.get(abstractType);
+    if (!implementerFields) {
+      implementerFields = new Map();
+      this._abstractImplementerFields.set(abstractType, implementerFields);
+    }
+
+    // Unlike the original approach this replaced, `as` is *not* stripped here:
+    // the field as synthesized onto the abstract type's own schema keeps
+    // `options.as === abstractType`, redundant/self-referential as that is.
+    // This keeps every contributor - implementers and the abstract type's
+    // own schema alike - declaring the same thing, which is what
+    // `assertConsistentAbstractFieldShape` checks, and it is also what lets
+    // `assertPolymorphicType` (which reads a field's declared `as` off
+    // whatever `schema.fields()` serves for its type) correctly permit the
+    // abstract type itself to be pushed directly into this relationship.
+    const abstractField = {
+      ...field
+    };
+    const contribution = {
+      field: abstractField,
+      source: implementer
+    };
+
+    // all concrete implementations of an abstract type are required to
+    // share the same shape for the field that implements it, so the first
+    // one registered is as good a canonical source as any - but a later,
+    // differently-shaped one is almost certainly a mistake rather than an
+    // intentional override, so we catch it rather than silently ignoring it.
+    const existingImplementer = implementerFields.get(field.name);
+    if (existingImplementer) {
+      return;
+    }
+    implementerFields.set(field.name, contribution);
+    let abstractSchema = this._schemas.get(abstractType);
+    if (!abstractSchema) {
+      abstractSchema = {
+        original: {
+          legacy: true,
+          identity: {
+            kind: '@id',
+            name: 'id'
+          },
+          type: abstractType,
+          fields: []
+        },
+        finalized: true,
+        fields: new Map(),
+        cacheFields: new Map(),
+        relationships: {},
+        attributes: {},
+        traits: new Set()
+      };
+      this._schemas.set(abstractType, abstractSchema);
+    }
+    const existingAbstractField = abstractSchema.fields.get(field.name);
+    if (existingAbstractField) {
+      return;
+    }
+    abstractSchema.fields.set(field.name, abstractField);
+    abstractSchema.relationships[field.name] = abstractField;
+
+    // If the schema is mid-finalization (traits pending), finalizeResource
+    // will recompute cacheFields from the current `fields` map anyway; avoid
+    // doing so prematurely from a partially-resolved set of fields.
+    if (abstractSchema.finalized) {
+      abstractSchema.cacheFields = getCacheFields(abstractSchema);
+    }
   }
 
   /**
@@ -7342,7 +7465,29 @@ globalThis.setWarpDriveIsMaybeMirage = setIsMaybeMirage;
  */
 function useRecommendedStore(options, StoreKlass = Store) {
   return class AppStore extends StoreKlass {
-    requestManager = new RequestManager().use([...(options.handlers ?? []), Fetch]).useCache(CacheHandler);
+    constructor(createArgs) {
+      super(createArgs);
+      // installed via defineProperty (rather than a class field/accessor) so that
+      // this lazy override of the inherited `requestManager` field does not
+      // conflict with the documented pattern of assigning it directly on
+      // consumer-authored Store subclasses. The setter preserves the ability
+      // to replace `requestManager` outright after construction.
+      let requestManager;
+      Object.defineProperty(this, 'requestManager', {
+        configurable: true,
+        enumerable: true,
+        get: () => {
+          if (!requestManager) {
+            const handlers = typeof options.handlers === 'function' ? options.handlers(this) : options.handlers ?? [];
+            requestManager = new RequestManager().use([...handlers, Fetch]).useCache(CacheHandler);
+          }
+          return requestManager;
+        },
+        set: value => {
+          requestManager = value;
+        }
+      });
+    }
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
       // 15 minutes

package/dist/unpkg/prod/index.js

@@ -1,4 +1,4 @@
-export { C as CacheHandler, F as Fetch, v as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, A as setIdentifierForgetMethod, y as setIdentifierGenerationMethod, B as setIdentifierResetMethod, z as setIdentifierUpdateMethod, D as setKeyInfoForResource, s as storeFor, x as useRecommendedStore } from "./index-BMBm3kYx.js";
+export { C as CacheHandler, F as Fetch, v as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, A as setIdentifierForgetMethod, y as setIdentifierGenerationMethod, B as setIdentifierResetMethod, z as setIdentifierUpdateMethod, D as setKeyInfoForResource, s as storeFor, x as useRecommendedStore } from "./index-C-AhVafS.js";
 import './types/-private.js';
 import "./-leaked-DgjQ5X55.js";
 import './store.js';

package/dist/unpkg/prod/reactive.js

@@ -1,4 +1,4 @@
-export { o as SchemaService, l as checkout, u as commit, p as fromIdentity, m as instantiateRecord, q as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-BMBm3kYx.js";
+export { o as SchemaService, l as checkout, u as commit, p as fromIdentity, m as instantiateRecord, q as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-C-AhVafS.js";
 export { a as Checkout } from "./-private-sql1_mdx.js";
 export { k as createRequestSubscription, m as getPromiseState, l as getRequestState } from "./-leaked-DgjQ5X55.js";
 import './types/-private.js';

package/dist/unpkg/prod/store/-private.js

@@ -1,6 +1,6 @@
 import '../types/-private.js';
-import { i as isResourceKey, c as coerceId } from "../index-BMBm3kYx.js";
-export { C as CacheHandler, R as RecordArrayManager, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, g as assertPrivateCapabilities, b as assertPrivateStore, k as createLegacyManyArray, e as ensureStringId, f as fastPush, d as isPrivateStore, a as isRequestKey, r as recordIdentifierFor, h as setRecordIdentifier, s as storeFor } from "../index-BMBm3kYx.js";
+import { i as isResourceKey, c as coerceId } from "../index-C-AhVafS.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, g as assertPrivateCapabilities, b as assertPrivateStore, k as createLegacyManyArray, e as ensureStringId, f as fastPush, d as isPrivateStore, a as isRequestKey, r as recordIdentifierFor, h as setRecordIdentifier, s as storeFor } from "../index-C-AhVafS.js";
 const TEXT_COLORS = {
   TEXT: 'inherit',
   notify: ['white', 'white', 'inherit', 'magenta', 'inherit'],

package/dist/unpkg/prod/types/-private.js

@@ -1,5 +1,5 @@
 const name = "@warp-drive/core";
-const version = "5.9.0-alpha.18";
+const version = "5.9.0-alpha.19";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import