@warp-drive/core 5.8.0-alpha.4 → 5.8.0-alpha.40

package/dist/reactive.js

@@ -1,784 +1,10 @@
-import { L as ReactiveResource, M as isNonIdentityCacheableField, N as getFieldCacheKeyStrict, r as recordIdentifierFor, H as withSignalStore, G as createInternalMemo } from "./request-state-CUuZzgvE.js";
-export { O as checkout, P as commit } from "./request-state-CUuZzgvE.js";
-import { isResourceSchema } from './types/schema/fields.js';
-import { D as Destroy, C as Context } from "./symbols-sql1_mdx.js";
+export { N as SchemaService, K as checkout, T as commit, p as createRequestSubscription, P as fromIdentity, U as getPromiseState, q as getRequestState, L as instantiateRecord, Q as registerDerivations, M as teardownRecord, O as withDefaults } from "./index-BKcD4JZK.js";
 export { a as Checkout } from "./symbols-sql1_mdx.js";
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { warn, deprecate } from '@ember/debug';
-import './index.js';
 import './types/request.js';
+import '@embroider/macros';
+import '@ember/debug';
 import './utils/string.js';
 import "./configure-C3x8YXzL.js";
-import { getOrSetGlobal } from './types/-private.js';
-import { Type } from './types/symbols.js';
-function instantiateRecord(store, identifier, createArgs) {
-  const schema = store.schema;
-  const resourceSchema = schema.resource(identifier);
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected a resource schema`);
-    }
-  })(isResourceSchema(resourceSchema)) : {};
-  const legacy = resourceSchema?.legacy ?? false;
-  const editable = legacy;
-  const record = new ReactiveResource({
-    store,
-    resourceKey: identifier,
-    modeName: legacy ? 'legacy' : 'polaris',
-    legacy: legacy,
-    editable: editable,
-    path: null,
-    field: null,
-    value: null
-  });
-  if (createArgs && editable) {
-    Object.assign(record, createArgs);
-  }
-  return record;
-}
-function assertReactiveResource(record) {
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error('Expected a ReactiveResource');
-    }
-  })(record && typeof record === 'object' && Destroy in record) : {};
-}
-function teardownRecord(record) {
-  assertReactiveResource(record);
-  record[Destroy]();
-}
-const Support = getOrSetGlobal('Support', new WeakMap());
-const ConstructorField = {
-  type: '@constructor',
-  name: 'constructor',
-  kind: 'derived'
-};
-const TypeField = {
-  type: '@identity',
-  name: '$type',
-  kind: 'derived',
-  options: {
-    key: 'type'
-  }
-};
-const DefaultIdentityField = {
-  name: 'id',
-  kind: '@id'
-};
-function _constructor(record) {
-  let state = Support.get(record);
-  if (!state) {
-    state = {};
-    Support.set(record, state);
-  }
-  return state._constructor = state._constructor || {
-    name: `ReactiveResource<${recordIdentifierFor(record).type}>`,
-    get modelName() {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        {
-          throw new Error(`record.constructor.modelName is not available outside of legacy mode`);
-        }
-      })() : {};
-      return undefined;
-    }
-  };
-}
-_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, resolvedType) {
-  // 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(resolvedType ? {
-      type: resolvedType
-    } : 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(resolvedType ? {
-    type: resolvedType
-  } : 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.
- *
- * Using this requires registering the PolarisMode derivations
- *
- * ```ts
- * import { registerDerivations } from '@warp-drive/schema-record';
- *
- * registerDerivations(schema);
- * ```
- *
- * @public
- * @param schema
- * @return {PolarisResourceSchema}
- */
-function withDefaults(schema) {
-  schema.identity = schema.identity || DefaultIdentityField;
-
-  // because fields gets iterated in definition order,
-  // we add TypeField to the beginning so that it will
-  // appear right next to the identity field
-  schema.fields.unshift(TypeField);
-  schema.fields.push(ConstructorField);
-  return schema;
-}
-/**
- * A derivation that computes its value from the
- * record's identity.
- *
- * It can be used via a derived field definition like:
- *
- * ```ts
- * {
- *   kind: 'derived',
- *   name: 'id',
- *   type: '@identity',
- *   options: { key: 'id' }
- * }
- * ```
- *
- * Valid keys are `'id'`, `'lid'`, `'type'`, and `'^'`.
- *
- * `^` returns the entire identifier object.
- *
- * @public
- */
-const fromIdentity = (record, options, key) => {
-  const context = record[Context];
-  const identifier = context.resourceKey;
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Cannot compute @identity for a record without an identifier`);
-    }
-  })(identifier) : {};
-  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-    if (!test) {
-      throw new Error(`Expected to receive a key to compute @identity, but got ${String(options)}`);
-    }
-  })(options?.key && ['lid', 'id', 'type', '^'].includes(options.key)) : {};
-  return options.key === '^' ? identifier : identifier[options.key];
-};
-fromIdentity[Type] = '@identity';
-
-/**
- * Registers the default derivations for records that want
- * to use the PolarisMode defaults provided by
- *
- * ```ts
- * import { withDefaults } from '@warp-drive/schema-record';
- * ```
- *
- * @public
- */
-function registerDerivations(schema) {
-  schema.registerDerivation(fromIdentity);
-  schema.registerDerivation(_constructor);
-}
-/**
- * Wraps a derivation in a new function with Derivation signature but that looks
- * up the value in the cache before recomputing.
- *
- * @internal
- */
-function makeCachedDerivation(derivation) {
-  const memoizedDerivation = (record, options, prop) => {
-    const signals = withSignalStore(record);
-    let signal = signals.get(prop);
-    if (!signal) {
-      signal = createInternalMemo(signals, record, prop, () => {
-        return derivation(record, options, prop);
-      }); // a total lie, for convenience of reusing the storage
-    }
-    return signal();
-  };
-  memoizedDerivation[Type] = derivation[Type];
-  return memoizedDerivation;
-}
-/**
- * A SchemaService designed to work with dynamically registered schemas.
- *
- * @public
- */
-class SchemaService {
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  constructor() {
-    this._schemas = new Map();
-    this._transforms = new Map();
-    this._hashFns = new Map();
-    this._derivations = new Map();
-    this._traits = new Map();
-    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());
-  }
-  hasTrait(type) {
-    return this._traits.has(type);
-  }
-  resourceHasTrait(resource, trait) {
-    return this._schemas.get(resource.type).traits.has(trait);
-  }
-  transformation(field) {
-    const kind = 'kind' in field ? field.kind : '<unknown kind>';
-    const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`'${kind}' fields cannot be transformed. Only fields of kind 'field' 'object' or 'array' can specify a transformation. Attempted to find '${field.type ?? '<unknown type>'}' on field '${name}'.`);
-      }
-    })(!('kind' in field) || ['field', 'object', 'array'].includes(kind)) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the '${kind}' field '${name}' to specify a transformation via 'field.type', but none was present`);
-      }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No transformation registered with name '${field.type}' for '${kind}' field '${name}'`);
-      }
-    })(this._transforms.has(field.type)) : {};
-    return this._transforms.get(field.type);
-  }
-  derivation(field) {
-    const kind = 'kind' in field ? field.kind : '<unknown kind>';
-    const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`The '${kind}' field '${name}' is not derived and so cannot be used to lookup a derivation`);
-      }
-    })(!('kind' in field) || kind === 'derived') : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the '${kind}' field '${name}' to specify a derivation via 'field.type', but no value was present`);
-      }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No '${field.type}' derivation registered for use by the '${kind}' field '${name}'`);
-      }
-    })(this._derivations.has(field.type)) : {};
-    return this._derivations.get(field.type);
-  }
-  hashFn(field) {
-    const kind = 'kind' in field ? field.kind : '<unknown kind>';
-    const name = 'name' in field ? field.name : '<unknown name>';
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`The '${kind}' field '${name}' is not a HashField and so cannot be used to lookup a hash function`);
-      }
-    })(!('kind' in field) || kind === '@hash') : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Expected the '${kind}' field '${name}' to specify a hash function via 'field.type', but no value was present`);
-      }
-    })(field.type) : {};
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No '${field.type}' hash function is registered for use by the '${kind}' field '${name}'`);
-      }
-    })(this._hashFns.has(field.type)) : {};
-    return this._hashFns.get(field.type);
-  }
-  resource(resource) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No resource registered with name '${resource.type}'`);
-      }
-    })(this._schemas.has(resource.type)) : {};
-    return this._schemas.get(resource.type).original;
-  }
-  registerResources(schemas) {
-    schemas.forEach(schema => {
-      this.registerResource(schema);
-    });
-  }
-  registerResource(schema) {
-    const fields = new Map();
-    const relationships = {};
-    const attributes = {};
-    for (const field of schema.fields) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`${field.kind} is not valid inside a ResourceSchema's fields.`);
-        }
-      })(
-      // @ts-expect-error we are checking for mistakes at runtime
-      field.kind !== '@id' && field.kind !== '@hash') : {};
-      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;
-      }
-    }
-    const cacheFields = null;
-    const traits = new Set(isResourceSchema(schema) ? schema.traits : []);
-    const finalized = traits.size === 0;
-    const internalSchema = {
-      original: schema,
-      finalized,
-      fields,
-      cacheFields,
-      relationships,
-      attributes,
-      traits
-    };
-    if (traits.size === 0) {
-      internalSchema.cacheFields = getCacheFields(internalSchema);
-    }
-    this._schemas.set(schema.type, internalSchema);
-  }
-
-  /**
-   * Registers a {@link Trait} for use by resource schemas.
-   *
-   * Traits are re-usable collections of fields that can be composed to
-   * build up a resource schema. Often they represent polymorphic behaviors
-   * a resource should exhibit.
-   *
-   * When we finalize a resource, we walk its traits and apply their fields
-   * to the resource's fields. All specified traits must be registered by
-   * this time or an error will be thrown.
-   *
-   * Traits are applied left-to-right, with traits of traits being applied in the same
-   * way. Thus for the most part, application of traits is a post-order graph traversal
-   * problem.
-   *
-   * A trait is only ever processed once. If multiple traits (A, B, C) have the same
-   * trait (D) as a dependency, D will be included only once when first encountered by
-   * A.
-   *
-   * If a cycle exists such that trait A has trait B which has Trait A, trait A will
-   * be applied *after* trait B in production. In development a cycle error will be thrown.
-   *
-   * Fields are finalized on a "last wins principle". Thus traits appearing higher in
-   * the tree and further to the right of a traits array take precedence, with the
-   * resource's fields always being applied last and winning out.
-   *
-   * @public
-   */
-  registerTrait(trait) {
-    const internalTrait = Object.assign({}, trait, {
-      fields: new Map()
-    });
-    for (const field of trait.fields) {
-      internalTrait.fields.set(field.name, field);
-    }
-    this._traits.set(trait.name, internalTrait);
-  }
-  registerTransformation(transformation) {
-    this._transforms.set(transformation[Type], transformation);
-  }
-  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', null);
-  }
-  CAUTION_MEGA_DANGER_ZONE_objectExtensions(field, resolvedType) {
-    return processExtensions(this, field, 'object', resolvedType);
-  }
-  CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field) {
-    return processExtensions(this, field, 'array', null);
-  }
-  CAUTION_MEGA_DANGER_ZONE_hasExtension(ext) {
-    return this._extensions[ext.kind].has(ext.name);
-  }
-
-  /**
-   * This is an internal method used to register behaviors for legacy mode.
-   * It is not intended for public use.
-   *
-   * We do think a generalized `kind` registration system would be useful,
-   * but we have not yet designed it.
-   *
-   * See https://github.com/warp-drive-data/warp-drive/issues/9534
-   *
-   * @internal
-   */
-  _registerMode(mode, kinds) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Mode '${mode}' is already registered`);
-      }
-    })(!this._modes.has(mode)) : {};
-    this._modes.set(mode, kinds);
-  }
-
-  /**
-   * This is an internal method used to enable legacy behaviors for legacy mode.
-   * It is not intended for public use.
-   *
-   * We do think a generalized `kind` registration system would be useful,
-   * but we have not yet designed it.
-   *
-   * See https://github.com/warp-drive-data/warp-drive/issues/9534
-   *
-   * @internal
-   */
-  _kind(mode, kind) {
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Mode '${mode}' is not registered`);
-      }
-    })(this._modes.has(mode)) : {};
-    const kinds = this._modes.get(mode);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Kind '${kind}' is not registered for mode '${mode}'`);
-      }
-    })(kinds[kind]) : {};
-    return kinds[kind];
-  }
-
-  /**
-   * Registers a {@link HashFn} for use with a {@link HashField} for
-   * either {@link ObjectSchema} identity or polymorphic type calculation.
-   *
-   * @public
-   */
-  registerHashFn(hashFn) {
-    this._hashFns.set(hashFn[Type], hashFn);
-  }
-  fields({
-    type
-  }) {
-    const schema = this._schemas.get(type);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No schema defined for ${type}`);
-      }
-    })(schema) : {};
-    if (!schema.finalized) {
-      finalizeResource(this, schema);
-    }
-    return schema.fields;
-  }
-  cacheFields({
-    type
-  }) {
-    const schema = this._schemas.get(type);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`No schema defined for ${type}`);
-      }
-    })(schema) : {};
-    if (!schema.finalized) {
-      finalizeResource(this, schema);
-    }
-    return schema.cacheFields;
-  }
-  hasResource(resource) {
-    return this._schemas.has(resource.type);
-  }
-}
-if (macroCondition(getGlobalConfig().WarpDrive.deprecations.ENABLE_LEGACY_SCHEMA_SERVICE)) {
-  SchemaService.prototype.attributesDefinitionFor = function ({
-    type
-  }) {
-    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.attributesDefinitionFor({ type })\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
-    const schema = this._schemas.get(type);
-    if (!schema) {
-      throw new Error(`No schema defined for ${type}`);
-    }
-    return schema.attributes;
-  };
-  SchemaService.prototype.relationshipsDefinitionFor = function ({
-    type
-  }) {
-    deprecate(`Use \`schema.fields({ type })\` instead of \`schema.relationshipsDefinitionFor({ type })\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
-    const schema = this._schemas.get(type);
-    if (!schema) {
-      throw new Error(`No schema defined for ${type}`);
-    }
-    return schema.relationships;
-  };
-  SchemaService.prototype.doesTypeExist = function (type) {
-    deprecate(`Use \`schema.hasResource({ type })\` instead of \`schema.doesTypeExist(type)\``, false, {
-      id: 'ember-data:schema-service-updates',
-      until: '6.0',
-      for: 'ember-data',
-      since: {
-        available: '4.13',
-        enabled: '5.4'
-      }
-    });
-    return this._schemas.has(type);
-  };
-}
-
-/**
- * When we finalize a resource, we walk its traits and apply their fields
- * to the resource's fields.
- *
- * Traits are applied left-to-right, with traits of traits being applied in the same
- * way. Thus for the most part, application of traits is a post-order graph traversal
- * problem.
- *
- * A trait is only ever processed once. If multiple traits (A, B, C) have the same
- * trait (D) as a dependency, D will be included only once when first encountered by
- * A.
- *
- * If a cycle exists such that trait A has trait B which has Trait A, trait A will
- * be applied *after* trait B in production. In development a cycle error will be thrown.
- *
- * Fields are finalized on a "last wins principle". Thus traits appearing higher in
- * the tree and further to the right of a traits array take precedence, with the
- * resource's fields always being applied last and winning out.
- */
-function finalizeResource(schema, resource) {
-  const fields = new Map();
-  const seen = new Set();
-  for (const traitName of resource.traits) {
-    const trait = schema._traits.get(traitName);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`The trait ${traitName} MUST be supplied before the resource ${resource.original.type} can be finalized for use.`);
-      }
-    })(trait) : {};
-    walkTrait(schema, trait, fields, seen, resource.original.type, macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? [] : null);
-  }
-  mergeMap(fields, resource.fields);
-  resource.fields = fields;
-  resource.cacheFields = getCacheFields(resource);
-  resource.finalized = true;
-}
-function getCacheFields(resource) {
-  const {
-    fields
-  } = resource;
-  const cacheFields = new Map();
-  for (const [key, value] of fields) {
-    if (isNonIdentityCacheableField(value)) {
-      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-        if (!test) {
-          throw new Error(`The sourceKey '${value.sourceKey}' for the field '${key}' on ${resource.original.type} is invalid because it matches the name of an existing field`);
-        }
-      })(!value.sourceKey || value.sourceKey === key || !fields.has(value.sourceKey)) : {};
-      const cacheKey = getFieldCacheKeyStrict(value);
-      cacheFields.set(cacheKey, value);
-    }
-  }
-  return cacheFields;
-}
-function walkTrait(schema, trait, fields, seen, type, debugPath) {
-  if (seen.has(trait)) {
-    // if the trait is in the current path, we throw a cycle error in dev.
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      if (debugPath.includes(trait.name)) {
-        throw new Error(`CycleError: The Trait '${trait.name}' utilized by the Resource '${type}' includes the following circular reference "${debugPath.join(' > ')} > ${trait.name}"`);
-      }
-    }
-    return;
-  }
-  const ownPath = macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? [...debugPath, trait.name] : null;
-
-  // immediately mark as seen to prevent cycles
-  // further down the tree from looping back
-  seen.add(trait);
-
-  // first apply any child traits
-  if (trait.traits?.length) {
-    for (const traitName of trait.traits) {
-      const subtrait = schema._traits.get(traitName);
-      if (macroCondition(getGlobalConfig().WarpDrive.features.ENFORCE_STRICT_RESOURCE_FINALIZATION)) {
-        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-          if (!test) {
-            throw new Error(`The trait ${traitName} used by the trait ${trait.name} MUST be supplied before the resource ${type} can be finalized for use.`);
-          }
-        })(subtrait) : {};
-      } else {
-        warn(`The trait ${traitName} used by the trait ${trait.name} MUST be supplied before the resource ${type} can be finalized for use.`, !!subtrait, {
-          id: 'warp-drive:missing-trait-schema-for-resource'
-        });
-      }
-      if (!subtrait) continue;
-      walkTrait(schema, subtrait, fields, seen, type, ownPath);
-    }
-  }
-
-  // then apply our own fields
-  mergeMap(fields, trait.fields);
-}
-function mergeMap(base, toApply) {
-  for (const [key, value] of toApply) {
-    base.set(key, value);
-  }
-}
 const Subscriptions = new WeakMap();
 
 /**
@@ -900,4 +126,4 @@ function getExpensiveRequestSubscription(store, requestKey, callback) {
     subscription.removeWatcher(callback);
   };
 }
-export { SchemaService, fromIdentity, getExpensiveRequestSubscription, instantiateRecord, registerDerivations, teardownRecord, withDefaults };
+export { getExpensiveRequestSubscription };