@warp-drive/core 5.6.0-alpha.14 → 5.6.0-alpha.17

package/dist/reactive.js

@@ -1,13 +1,13 @@
 import { isResourceSchema } from './types/schema/fields.js';
-import { B as withSignalStore, w as entangleSignal, E as consumeInternalSignal, d as SOURCE$1, f as fastPush, x as defineSignal, l as RelatedCollection, F as getOrCreateInternalSignal, D as notifyInternalSignal, z as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-DgwTEXLU.js";
+import { E as withSignalStore, Q as isExtensionProp, T as performExtensionSet, G as consumeInternalSignal, U as performArrayExtensionGet, x as entangleSignal, V as performObjectExtensionGet, d as SOURCE$1, f as fastPush, y as defineSignal, l as RelatedCollection, H as getOrCreateInternalSignal, F as notifyInternalSignal, A as Signals, h as setRecordIdentifier, r as recordIdentifierFor } from "./request-state-CjLph1LP.js";
 import { EnableHydration, STRUCTURED } from './types/request.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { deprecate } from '@ember/debug';
 import './utils/string.js';
-import { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo } from "./configure-BgaZESRo.js";
+import { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, c as createMemo } from "./configure-B48bFHOl.js";
 import { RecordStore, Type } from './types/symbols.js';
 import { getOrSetGlobal } from './types/-private.js';
-import { S as SOURCE, E as Editable, L as Legacy, I as Identifier, P as Parent, a as EmbeddedPath, D as Destroy, C as Checkout, b as EmbeddedType } from "./symbols-BmDcn6hS.js";
+import { S as SOURCE, E as Editable, L as Legacy, I as Identifier, P as Parent, a as EmbeddedPath, D as Destroy, C as Checkout, b as EmbeddedField } from "./symbols-SIstXMLI.js";
 import './index.js';
 const ARRAY_GETTER_METHODS = new Set([Symbol.iterator, 'concat', 'entries', 'every', 'fill', 'filter', 'find', 'findIndex', 'flat', 'flatMap', 'forEach', 'includes', 'indexOf', 'join', 'keys', 'lastIndexOf', 'map', 'reduce', 'reduceRight', 'slice', 'some', 'values']);
 // const ARRAY_SETTER_METHODS = new Set<KeyType>(['push', 'pop', 'unshift', 'shift', 'splice', 'sort']);
@@ -53,19 +53,16 @@ function safeForEach(instance, arr, store, callback, target) {
   }
   return instance;
 }
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class ManagedArray {
-  [SOURCE];
   constructor(store, schema, cache, field, data, identifier, path, owner, isSchemaArray, editable, legacy) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     this[SOURCE] = data?.slice();
     const IS_EDITABLE = this[Editable] = editable ?? false;
     this[Legacy] = legacy;
-
-    // FIXME probably can get rid of the manual ARRAY_SIGNAL storage
-    // FIXME probably the storage should be on the proxy/receiver not this class
     const signals = withSignalStore(this);
-    const _SIGNAL = this[ARRAY_SIGNAL] = entangleSignal(signals, this, ARRAY_SIGNAL, undefined);
+    let _SIGNAL = null;
     const boundFns = new Map();
     this.identifier = identifier;
     this.path = path;
@@ -81,6 +78,7 @@ class ManagedArray {
     // into two separate methods.
     Map;
     const ManagedRecordRefs = isSchemaArray ? new RefStorage() : null;
+    const extensions = legacy ? schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) : null;
     const proxy = new Proxy(this[SOURCE], {
       get(target, prop, receiver) {
         if (prop === ARRAY_SIGNAL) {
@@ -101,6 +99,10 @@ class ManagedArray {
             self[SOURCE].push(...newData);
           }
         }
+        if (prop === 'length') {
+          return consumeInternalSignal(_SIGNAL), target.length;
+        }
+        if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
         if (index !== null) {
           let val;
           if (mode === '@hash') {
@@ -159,7 +161,7 @@ class ManagedArray {
                 record = new ReactiveResource(store, recordIdentifier, {
                   [Editable]: self.owner[Editable],
                   [Legacy]: self.owner[Legacy]
-                }, true, field.type, recordPath);
+                }, true, field, recordPath);
                 // if mode is not @identity or @index, then access the key path now
                 // to determine the key value.
                 // chris says we can implement this as a special kind `@hash` which
@@ -224,6 +226,9 @@ class ManagedArray {
           }
           return fn;
         }
+        if (isExtensionProp(extensions, prop)) {
+          return performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, v => void (transaction = v));
+        }
         return Reflect.get(target, prop, receiver);
       },
       set(target, prop, value, receiver) {
@@ -235,15 +240,16 @@ class ManagedArray {
           throw new Error(`Cannot set ${String(prop)} on ${errorPath} because the record is not editable`);
         }
         if (prop === 'identifier') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           self.identifier = value;
           return true;
         }
         if (prop === 'owner') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           self.owner = value;
           return true;
         }
+        if (isExtensionProp(extensions, prop)) {
+          return performExtensionSet(receiver, extensions, signals, prop, value);
+        }
         const reflect = Reflect.set(target, prop, value, receiver);
         if (reflect) {
           if (!field.type) {
@@ -271,13 +277,36 @@ class ManagedArray {
         return Reflect.has(target, prop);
       }
     });
+
+    // we entangle the signal on the returned proxy since that is
+    // the object that other code will be interfacing with.
+    _SIGNAL = entangleSignal(signals, proxy, ARRAY_SIGNAL, undefined);
     return proxy;
   }
 }
+
+// this will error if someone tries to call
+// A(identifierArray) since it is not configurable
+// which is preferable to the `meta` override we used
+// before which required importing all of Ember
+const desc = {
+  enumerable: true,
+  configurable: false,
+  get: function () {
+    // here to support computed chains
+    // and {{#each}}
+    if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_COMPUTED_CHAINS)) {
+      return this;
+    }
+  }
+};
+// compat(desc);
+Object.defineProperty(ManagedArray.prototype, '[]', desc);
 const ObjectSymbols = new Set([OBJECT_SIGNAL, Parent, SOURCE, Editable, EmbeddedPath]);
 
 // const ignoredGlobalFields = new Set<string>(['setInterval', 'nodeType', 'nodeName', 'length', 'document', STRUCTURED]);
 
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class ManagedObject {
   constructor(schema, cache, field, data, identifier, path, owner, editable, legacy) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -291,6 +320,9 @@ class ManagedObject {
     this[Legacy] = legacy;
     this[Parent] = identifier;
     this[EmbeddedPath] = path;
+
+    // prettier-ignore
+    const extensions = !legacy ? null : schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(field);
     const proxy = new Proxy(this[SOURCE], {
       ownKeys() {
         return Object.keys(self[SOURCE]);
@@ -328,11 +360,6 @@ class ManagedObject {
             return '<span>ManagedObject</span>';
           };
         }
-        if (prop === 'toJSON') {
-          return function () {
-            return structuredClone(self[SOURCE]);
-          };
-        }
         if (_SIGNAL.isStale) {
           _SIGNAL.isStale = false;
           let newData = cache.getAttr(identifier, path);
@@ -346,10 +373,22 @@ class ManagedObject {
             }; // Add type assertion for newData
           }
         }
+
+        // toJSON and extensions need to come after we update data if stale
+        if (prop === 'toJSON') {
+          return function () {
+            return structuredClone(self[SOURCE]);
+          };
+        }
+
+        // we always defer to data before extensions
         if (prop in self[SOURCE]) {
           consumeInternalSignal(_SIGNAL);
           return self[SOURCE][prop];
         }
+        if (isExtensionProp(extensions, prop)) {
+          return performObjectExtensionGet(receiver, extensions, signals, prop);
+        }
         return Reflect.get(target, prop, receiver);
       },
       set(target, prop, value, receiver) {
@@ -358,6 +397,12 @@ class ManagedObject {
             throw new Error(`Cannot set read-only property '${String(prop)}' on ManagedObject`);
           }
         })(editable) : {};
+
+        // since objects function as dictionaries, we can't defer to schema/data before extensions
+        // unless the prop is in the existing data.
+        if (!(prop in self[SOURCE]) && isExtensionProp(extensions, prop)) {
+          return performExtensionSet(receiver, extensions, signals, prop, value);
+        }
         const reflect = Reflect.set(target, prop, value, receiver);
         if (!reflect) {
           return false;
@@ -553,7 +598,7 @@ function computeSchemaObject(store, cache, record, identifier, field, path, lega
     schemaObject = new ReactiveResource(store, identifier, {
       [Editable]: editable,
       [Legacy]: legacy
-    }, true, field.type, embeddedPath);
+    }, true, field, embeddedPath);
   }
   if (!schemaObjectMapForRecord) {
     ManagedObjectMap.set(record, new Map([[field.name, schemaObject]]));
@@ -568,7 +613,6 @@ function computeAttribute(cache, identifier, prop, editable) {
 function computeDerivation(schema, record, identifier, field, prop) {
   return schema.derivation(field)(record, field.options ?? null, prop);
 }
-
 // TODO probably this should just be a Document
 // but its separate until we work out the lid situation
 class ResourceRelationship {
@@ -645,6 +689,7 @@ function computeHasMany(store, schema, cache, record, identifier, field, path, e
       type: field.type,
       identifier,
       cache,
+      field: legacy ? field : undefined,
       // we divorce the reference here because ManyArray mutates the target directly
       // before sending the mutation op to the cache. We may be able to avoid this in the future
       identifiers: rawValue.data?.slice(),
@@ -669,7 +714,7 @@ function computeHasMany(store, schema, cache, record, identifier, field, path, e
   return managedArray;
 }
 const IgnoredGlobalFields = new Set(['length', 'nodeType', 'then', 'setInterval', 'document', STRUCTURED]);
-const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, EmbeddedPath, EmbeddedType];
+const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, EmbeddedPath, EmbeddedField];
 const RecordSymbols = new Set(symbolList);
 function isPathMatch(a, b) {
   return a.length === b.length && a.every((v, i) => v === b[i]);
@@ -690,24 +735,9 @@ const Editables = new WeakMap();
  * @hideconstructor
  * @public
  */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class ReactiveResource {
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  constructor(store, identifier, Mode, isEmbedded = false, embeddedType = null, embeddedPath = null) {
+  constructor(store, identifier, Mode, isEmbedded = false, embeddedField = null, embeddedPath = null) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     this[RecordStore] = store;
@@ -720,15 +750,14 @@ class ReactiveResource {
     this[Legacy] = Mode[Legacy] ?? false;
     const schema = store.schema;
     const cache = store.cache;
-    const identityField = schema.resource(isEmbedded ? {
-      type: embeddedType
-    } : identifier).identity;
+    const identityField = schema.resource(isEmbedded ? embeddedField : identifier).identity;
     const BoundFns = new Map();
-    this[EmbeddedType] = embeddedType;
+
+    // prettier-ignore
+    const extensions = !Mode[Legacy] ? null : isEmbedded ? schema.CAUTION_MEGA_DANGER_ZONE_objectExtensions(embeddedField) : schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(identifier);
+    this[EmbeddedField] = embeddedField;
     this[EmbeddedPath] = embeddedPath;
-    const fields = isEmbedded ? schema.fields({
-      type: embeddedType
-    }) : schema.fields(identifier);
+    const fields = isEmbedded ? schema.fields(embeddedField) : schema.fields(identifier);
     const signals = withSignalStore(this);
     const proxy = new Proxy(this, {
       ownKeys() {
@@ -799,6 +828,12 @@ class ReactiveResource {
       },
       get(target, prop, receiver) {
         if (RecordSymbols.has(prop)) {
+          if (prop === Destroy) {
+            return () => _DESTROY(receiver);
+          }
+          if (prop === Checkout) {
+            return () => _CHECKOUT(receiver);
+          }
           return target[prop];
         }
         if (prop === Signals) {
@@ -880,11 +915,15 @@ class ReactiveResource {
           if (prop === 'constructor') {
             return ReactiveResource;
           }
+          if (isExtensionProp(extensions, prop)) {
+            return performObjectExtensionGet(receiver, extensions, signals, prop);
+          }
+
           // too many things check for random symbols
           if (typeof prop === 'symbol') return undefined;
           macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
             {
-              throw new Error(`No field named ${String(prop)} on ${isEmbedded ? embeddedType : identifier.type}`);
+              throw new Error(`No field named ${String(prop)} on ${isEmbedded ? embeddedField.type : identifier.type}`);
             }
           })() : {};
           return undefined;
@@ -967,13 +1006,21 @@ class ReactiveResource {
       },
       set(target, prop, value, receiver) {
         if (!IS_EDITABLE) {
-          const type = isEmbedded ? embeddedType : identifier.type;
+          const type = isEmbedded ? embeddedField.type : identifier.type;
           throw new Error(`Cannot set ${String(prop)} on ${type} because the record is not editable`);
         }
         const maybeField = prop === identityField?.name ? identityField : fields.get(prop);
         if (!maybeField) {
-          const type = isEmbedded ? embeddedType : identifier.type;
-          throw new Error(`There is no field named ${String(prop)} on ${type}`);
+          const type = isEmbedded ? embeddedField.type : identifier.type;
+          if (isExtensionProp(extensions, prop)) {
+            return performExtensionSet(receiver, extensions, signals, prop, value);
+          }
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            {
+              throw new Error(`There is no settable field named ${String(prop)} on ${type}`);
+            }
+          })() : {};
+          return false;
         }
         const field = maybeField.kind === 'alias' ? maybeField.options : maybeField;
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -1318,57 +1365,37 @@ class ReactiveResource {
     }
     return proxy;
   }
-
-  /** @internal */
-  [Destroy]() {
-    if (this[Legacy]) {
-      // @ts-expect-error
-      this.isDestroying = true;
-      // @ts-expect-error
-      this.isDestroyed = true;
-    }
-    this[RecordStore].notifications.unsubscribe(this.___notifications);
+}
+function _CHECKOUT(record) {
+  // IF we are already the editable record, throw an error
+  if (record[Editable]) {
+    throw new Error(`Cannot checkout an already editable record`);
   }
-
-  /**
-   * Create an editable copy of the record
-   *
-   * ReactiveResource instances are not editable by default. This method creates an editable copy of the record. To use,
-   * import the `Checkout` symbol from `@warp-drive/schema-record` and call it on the record.
-   *
-   * ```ts
-   * import { Checkout } from '@warp-drive/schema-record';
-   *
-   * const record = store.peekRecord('user', '1');
-   * const editableRecord = await record[Checkout]();
-   * ```
-   *
-   * @returns a promise that resolves to the editable record
-   * @throws if the record is already editable or if the record is embedded
-   *
-   */
-  [Checkout]() {
-    // IF we are already the editable record, throw an error
-    if (this[Editable]) {
-      throw new Error(`Cannot checkout an already editable record`);
-    }
-    const editable = Editables.get(this);
-    if (editable) {
-      return Promise.resolve(editable);
-    }
-    const embeddedType = this[EmbeddedType];
-    const embeddedPath = this[EmbeddedPath];
-    const isEmbedded = embeddedType !== null && embeddedPath !== null;
-    if (isEmbedded) {
-      throw new Error(`Cannot checkout an embedded record (yet)`);
-    }
-    const editableRecord = new ReactiveResource(this[RecordStore], this[Identifier], {
-      [Editable]: true,
-      [Legacy]: this[Legacy]
-    }, isEmbedded, embeddedType, embeddedPath);
-    setRecordIdentifier(editableRecord, recordIdentifierFor(this));
-    return Promise.resolve(editableRecord);
+  const editable = Editables.get(record);
+  if (editable) {
+    return Promise.resolve(editable);
+  }
+  const embeddedType = record[EmbeddedField];
+  const embeddedPath = record[EmbeddedPath];
+  const isEmbedded = embeddedType !== null && embeddedPath !== null;
+  if (isEmbedded) {
+    throw new Error(`Cannot checkout an embedded record (yet)`);
   }
+  const editableRecord = new ReactiveResource(record[RecordStore], record[Identifier], {
+    [Editable]: true,
+    [Legacy]: record[Legacy]
+  }, isEmbedded, embeddedType, embeddedPath);
+  setRecordIdentifier(editableRecord, recordIdentifierFor(record));
+  return Promise.resolve(editableRecord);
+}
+function _DESTROY(record) {
+  if (record[Legacy]) {
+    // @ts-expect-error
+    record.isDestroying = true;
+    // @ts-expect-error
+    record.isDestroyed = true;
+  }
+  record[RecordStore].notifications.unsubscribe(record.___notifications);
 }
 function instantiateRecord(store, identifier, createArgs) {
   const schema = store.schema;
@@ -1438,6 +1465,139 @@ function _constructor(record) {
 }
 _constructor[Type] = '@constructor';
 
+/**
+ * Extensions allow providing non-schema driven behaviors to
+ * reactive resources and arrays.
+ */
+
+const BannedKeys = ['constructor', '__proto__'];
+function processExtension(extension) {
+  const {
+    kind,
+    name
+  } = extension;
+  const features = new Map();
+  const baseFeatures = typeof extension.features === 'function' ? extension.features.prototype : extension.features;
+  for (const key of Object.getOwnPropertyNames(baseFeatures)) {
+    if (BannedKeys.includes(key)) continue;
+    const decl = Object.getOwnPropertyDescriptor(baseFeatures, key);
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected to find a declaration for ${key} on extension ${name}`);
+      }
+    })(decl) : {};
+    if (decl.value) {
+      const {
+        value
+      } = decl;
+      features.set(key, typeof value === 'function' ? {
+        kind: 'method',
+        fn: value
+      } : decl.writable ? {
+        kind: 'mutable-value',
+        value
+      } : {
+        kind: 'readonly-value',
+        value
+      });
+      continue;
+    }
+    if (decl.get || decl.set) {
+      const {
+        get,
+        set
+      } = decl;
+      features.set(key,
+      // prettier-ignore
+      get && set ? {
+        kind: 'mutable-field',
+        get,
+        set
+      } : get ? {
+        kind: 'readonly-field',
+        get
+      } : {
+        kind: 'writeonly-field',
+        set: set
+      });
+      continue;
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      {
+        throw new Error(`The feature ${key} on extension ${name} is of an unknown variety.`);
+      }
+    })() : {};
+  }
+  return {
+    kind,
+    name,
+    features
+  };
+}
+function getExt(extCache, type, extName) {
+  const ext = extCache[type].get(extName);
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`expected to have an extension named ${String(extName)} available for ${type}s`);
+    }
+  })(ext) : {};
+  return ext?.features ?? null;
+}
+function hasObjectSchema(field) {
+  return 'kind' in field && (field.kind === 'schema-array' || field.kind === 'schema-object');
+}
+function processExtensions(schema, field, scenario) {
+  // if we're looking up extensions for a resource, there is no
+  // merging required so if we have no objectExtensions
+  // we are done.
+  if (scenario === 'resource') {
+    if (!('objectExtensions' in field || !field.objectExtensions?.length)) {
+      return null;
+    }
+  }
+  const type = scenario === 'resource' ? 'object' : scenario;
+  const extCache = schema._extensions;
+  const fieldCache = schema._cachedFieldExtensionsByField;
+  if (fieldCache[type].has(field)) {
+    return fieldCache[type].get(field);
+  }
+
+  // prettier-ignore
+  const extensions = (scenario === 'resource' ? field.objectExtensions : scenario === 'object' ? field.options?.objectExtensions : field.options?.arrayExtensions) || null;
+
+  // if we are a resource scenario, we know from the first check we do have extensions
+  // if we are an object scenario, we can now return the resource scenario.
+  // if we are an array scenario, there is nothing more to process.
+  if (!extensions) {
+    if (scenario === 'array') return null;
+    if (!hasObjectSchema(field)) {
+      return null;
+    }
+    return schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field);
+  }
+
+  // if we have made it here, we have extensions, lets check if there's
+  // a cached version we can use
+  const baseExtensions = scenario === 'resource' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : scenario === 'object' && hasObjectSchema(field) ? schema.CAUTION_MEGA_DANGER_ZONE_resourceExtensions(field) : null;
+  if (!baseExtensions && extensions.length === 1) {
+    const value = getExt(extCache, type, extensions[0]);
+    fieldCache[type].set(field, value);
+    return value;
+  }
+  const features = new Map(baseExtensions);
+  for (const extName of extensions) {
+    const value = getExt(extCache, type, extName);
+    if (value) {
+      for (const [feature, desc] of value) {
+        features.set(feature, desc);
+      }
+    }
+  }
+  const value = features.size ? features : null;
+  fieldCache[type].set(field, value);
+  return value;
+}
+
 /**
  * Utility for constructing a ResourceSchema with the recommended
  * fields for the PolarisMode experience.
@@ -1464,7 +1624,6 @@ function withDefaults(schema) {
   schema.fields.push(ConstructorField);
   return schema;
 }
-
 /**
  * A derivation that computes its value from the
  * record's identity.
@@ -1486,8 +1645,7 @@ function withDefaults(schema) {
  *
  * @public
  */
-
-function fromIdentity(record, options, key) {
+const fromIdentity = (record, options, key) => {
   const identifier = record[Identifier];
   macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
     if (!test) {
@@ -1500,7 +1658,7 @@ function fromIdentity(record, options, key) {
     }
   })(options?.key && ['lid', 'id', 'type', '^'].includes(options.key)) : {};
   return options.key === '^' ? identifier : identifier[options.key];
-}
+};
 fromIdentity[Type] = '@identity';
 
 /**
@@ -1559,6 +1717,8 @@ class SchemaService {
 
   /** @internal */
 
+  /** @internal */
+
   constructor() {
     this._schemas = new Map();
     this._transforms = new Map();
@@ -1566,6 +1726,14 @@ class SchemaService {
     this._derivations = new Map();
     this._traits = new Set();
     this._modes = new Map();
+    this._extensions = {
+      object: new Map(),
+      array: new Map()
+    };
+    this._cachedFieldExtensionsByField = {
+      object: new Map(),
+      array: new Map()
+    };
   }
   resourceTypes() {
     return Array.from(this._schemas.keys());
@@ -1687,6 +1855,24 @@ class SchemaService {
   registerDerivation(derivation) {
     this._derivations.set(derivation[Type], makeCachedDerivation(derivation));
   }
+  CAUTION_MEGA_DANGER_ZONE_registerExtension(extension) {
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`an extension named ${extension.name} for ${extension.kind} already exists!`);
+      }
+    })(!this._extensions[extension.kind].has(extension.name)) : {};
+    this._extensions[extension.kind].set(extension.name, processExtension(extension));
+  }
+  CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource) {
+    const schema = this.resource(resource);
+    return processExtensions(this, schema, 'resource');
+  }
+  CAUTION_MEGA_DANGER_ZONE_objectExtensions(field) {
+    return processExtensions(this, field, 'object');
+  }
+  CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) {
+    return processExtensions(this, field, 'array');
+  }
 
   /**
    * This is an internal method used to register behaviors for legacy mode.
@@ -1704,7 +1890,7 @@ class SchemaService {
       if (!test) {
         throw new Error(`Mode '${mode}' is already registered`);
       }
-    })(!this._traits.has(mode)) : {};
+    })(!this._modes.has(mode)) : {};
     this._modes.set(mode, kinds);
   }