@salesforce/lds-runtime-aura 1.316.0 → 1.318.0

package/dist/ldsEngineCreator.js

@@ -22,7 +22,7 @@ import applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLi
 import useExactMatchesPlusGate from '@salesforce/gate/lds.pdl.useExactMatchesPlus';
 import { GetApexWireAdapterFactory, registerPrefetcher as registerPrefetcher$1 } from 'force/ldsAdaptersApex';
 import { getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, coerceObjectIdArray, getObjectInfoAdapterFactory, coerceObjectId, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListInfoAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, getListInfoByNameAdapterFactory, getListInfosByObjectNameAdapterFactory, getListRecordsByNameAdapterFactory, getListObjectInfoAdapterFactory, instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
-import { BaseCommand, convertFetchResponseToData } from 'force/luvioRuntime5';
+import { getInstrumentation } from 'o11y/client';
 import { serviceBroker } from 'force/luvioServiceBroker5';
 import oneStoreEnabled from '@salesforce/gate/lds.oneStoreEnabled.ltng';
 import oneStoreUiapiEnabled from '@salesforce/gate/lds.oneStoreUiapiEnabled.ltng';
@@ -39,6 +39,20 @@ import useHttpInsteadAuraTransport from '@salesforce/gate/lds.useHttpInsteadAura
 import { ThirdPartyTracker } from 'instrumentation:beaconLib';
 import { getObjectInfo, getObjectInfos } from 'force/ldsAdaptersUiapiLex';
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * BaseCommand is an abstract implementation of SubscribableCommand. It adds the
+ * notions of typed configuration, request context, and a set of runtime services
+ * to the contract defined by Command/SubscribableCommand.
+ */
+class BaseCommand {
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -59,7 +73,7 @@ class NetworkCommand extends BaseCommand {
         return this.fetch();
     }
 }
-function buildNetworkCommandBaseClassService() {
+function buildServiceDescriptor$a() {
     return {
         type: 'networkCommandBaseClass',
         version: '1.0',
@@ -176,7 +190,7 @@ function toError(x) {
     if (x instanceof Error) {
         return x;
     }
-    return new Error(`${x}`);
+    return new Error(typeof x === 'string' ? x : JSON.stringify(x));
 }
 
 class Ok {
@@ -203,33 +217,6 @@ class Err {
 }
 const ok = (value) => new Ok(value);
 const err = (err) => new Err(err);
-// an error to indicate that the data inside a Result construct
-// is missing or incomplete
-class DataNotFoundError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'DataNotFoundError';
-    }
-}
-class DataIncompleteError extends Error {
-    constructor(message, partialData) {
-        super(message);
-        this.partialData = partialData;
-        this.name = 'DataIncompleteError';
-    }
-}
-function isDataNotFoundError(error) {
-    return error instanceof DataNotFoundError || error.name === 'DataNotFoundError';
-}
-function isDataIncompleteError(error) {
-    return error instanceof DataIncompleteError || error.name === 'DataIncompleteError';
-}
-function isCacheHitOrError(value) {
-    if (value.isErr() && (isDataIncompleteError(value.error) || isDataNotFoundError(value.error))) {
-        return false;
-    }
-    return true;
-}
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -256,8 +243,7 @@ function convertAuraResponseToData(responsePromise) {
 }
 
 /**
- * An implementation of BaseCommand that makes network requests but does not try to
- * use the store.
+ * An implementation of NetworkCommand that uses Aura as the transport mechanism
  */
 class AuraNetworkCommand extends NetworkCommand {
     constructor(services) {
@@ -274,7 +260,8 @@ class AuraNetworkCommand extends NetworkCommand {
         return convertAuraResponseToData(this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig));
     }
 }
-function buildAuraNetworkCommandBaseClassService() {
+
+function buildServiceDescriptor$9() {
     return {
         type: 'auraNetworkCommandBaseClass',
         version: '1.0',
@@ -290,8 +277,7 @@ function buildAuraNetworkCommandBaseClassService() {
 
 
 /**
- * An implementation of BaseCommand that makes network requests but does not try to
- * use the store.
+ * An implementation of NetworkCommand that uses HTTP/fetch as the transport mechanism.
  */
 class FetchNetworkCommand extends NetworkCommand {
     constructor(services) {
@@ -299,10 +285,21 @@ class FetchNetworkCommand extends NetworkCommand {
         this.services = services;
     }
     fetch() {
-        return convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+        return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    convertFetchResponseToData(response) {
+        return response.then((response) => {
+            if (response.ok) {
+                return response.json().then((json) => ok(json), (reason) => err(toError(reason)));
+            }
+            else {
+                return err(toError(response.statusText));
+            }
+        }, (reason) => err(toError(reason)));
     }
 }
-function buildFetchNetworkCommandBaseClassService() {
+
+function buildServiceDescriptor$8() {
     return {
         type: 'fetchNetworkCommandBaseClass',
         version: '1.0',
@@ -339,7 +336,8 @@ class StreamingCommand extends BaseCommand {
         }, (reason) => err(toError(reason)));
     }
 }
-function buildStreamingCommandBaseClassService() {
+
+function buildServiceDescriptor$7() {
     return {
         type: 'streamingCommandBaseClass',
         version: '1.0',
@@ -375,13 +373,6 @@ class SSECommand extends StreamingCommand {
             .pipeThrough(new SSEParsingStream()));
     }
 }
-function buildSSECommandBaseClassService() {
-    return {
-        type: 'SSECommandBaseClass',
-        version: '1.0',
-        service: SSECommand,
-    };
-}
 const sseRegex = /^(?<field>[^:]*?)(: ?(?<value>.*?))?(?:\r\n?|\n)/;
 //                 +-------v------++--------v--------++-----v----+
 //                         |                |               |
@@ -462,6 +453,14 @@ class SSEParsingStream extends TransformStream {
     }
 }
 
+function buildServiceDescriptor$6() {
+    return {
+        type: 'SSECommandBaseClass',
+        version: '1.0',
+        service: SSECommand,
+    };
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -503,11 +502,12 @@ function buildInstrumentCommand(services) {
         };
     };
 }
-function buildInstrumentCommandServiceDescriptor(services) {
+
+function buildServiceDescriptor$5(instrumentation) {
     return {
         type: 'instrumentCommand',
         version: '1.0',
-        service: buildInstrumentCommand(services),
+        service: buildInstrumentCommand({ instrumentation }),
     };
 }
 
@@ -517,271 +517,251 @@ function buildInstrumentCommandServiceDescriptor(services) {
  * For full license text, see the LICENSE.txt file
  */
 
-/**
- * A collection of keys, in no particular order.
- */
-class KeySetImpl {
-    constructor(initialKeys) {
-        // TODO - probably better to use Set<Key>
-        this.data = {};
-        this.lengthInternal = 0;
-        if (initialKeys) {
-            initialKeys.forEach((key) => {
-                this.add(key);
-            });
-        }
-    }
-    add(key) {
-        this.data[key] = true;
-        // TODO - need to account for adding a key that was already in the set
-        this.lengthInternal++;
+
+/* eslint-disable no-dupe-class-members */
+class O11yOTelTraceAPI {
+    constructor(services) {
+        this.services = services;
     }
-    contains(key) {
-        return this.data[key] === true;
+    getTracer(name, _version, _options) {
+        const o11yInstrumentation = getInstrumentation(name);
+        return new O11yTracer(o11yInstrumentation, this.services.logger);
     }
-    elements() {
-        return Object.keys(this.data);
+}
+class O11yTracer {
+    constructor(o11yInstrumentation, logger) {
+        this.o11yInstrumentation = o11yInstrumentation;
+        this.logger = logger;
     }
-    get length() {
-        return this.lengthInternal;
+    startSpan(name, _options, context) {
+        const traceId = context === null || context === void 0 ? void 0 : context.getValue(Symbol.for('traceId'));
+        const spanId = context === null || context === void 0 ? void 0 : context.getValue(Symbol.for('spanId'));
+        const traceFlags = context === null || context === void 0 ? void 0 : context.getValue(Symbol.for('traceFlags'));
+        let spanContext = undefined;
+        if (traceId !== undefined && spanId !== undefined && traceFlags !== undefined) {
+            spanContext = {
+                traceId,
+                spanId,
+                traceFlags,
+            };
+        }
+        const activityOptions = spanContext === undefined
+            ? undefined
+            : {
+                instrumentationContext: {
+                    rootId: spanContext.traceId,
+                    isRootActivitySampled: spanContext.traceFlags === 1,
+                    parentId: spanId,
+                },
+            };
+        const activity = this.o11yInstrumentation.startActivity(name, activityOptions);
+        return new O11ySpan(activity, this.logger);
     }
-    overlaps(other) {
-        const otherKeys = other.elements();
-        for (let j = 0; j < otherKeys.length; ++j) {
-            if (this.contains(otherKeys[j])) {
-                return true;
+    startActiveSpan(name, options, context, fn) {
+        let opts;
+        let ctx;
+        let fun;
+        if (typeof options === 'function') {
+            fun = options;
+        }
+        else {
+            opts = options;
+            if (typeof context === 'function') {
+                fun = context;
+            }
+            else {
+                ctx = context;
+                fun = fn;
             }
         }
-        return false;
+        const span = this.startSpan(name, opts, ctx);
+        return fun(span);
     }
-    difference(other) {
-        const value = new KeySetImpl();
-        this.elements().forEach((key) => {
-            if (!other.contains(key)) {
-                value.add(key);
-            }
-        });
-        return value;
+}
+class O11ySpan {
+    constructor(activity, logger) {
+        this.activity = activity;
+        this.logger = logger;
+        this._isRecording = true;
+        this.attributes = {};
     }
-    isSubsetOf(other) {
-        return this.difference(other).length === 0;
+    spanContext() {
+        return {
+            traceId: this.activity.getRootId(),
+            spanId: this.activity.getId(),
+            traceFlags: this.activity.getIsSampled() ? 1 : 0,
+        };
     }
-    equals(other) {
-        return this.length === other.length && this.elements().every((key) => other.contains(key));
+    setAttribute(key, value) {
+        this.attributes[key] = value;
+        return this;
     }
-    toString() {
-        return `<<${JSON.stringify(this.elements())}>>`;
+    setAttributes(attributes) {
+        this.attributes = { ...this.attributes, ...attributes };
+        return this;
     }
-}
-
-/**
- * A simple in-memory implementation of the Store interface.
- *
- * Exported for testing purposes only.
- */
-class InMemoryStore {
-    constructor() {
-        this.data = {};
+    addEvent(_name, _attributesOrStartTime, _startTime) {
+        this.logger.warn('O11ySpan does not support addEvents.');
+        return this;
     }
-    // TODO - only intended for use in tests. We should refactor this into a subclass &
-    // add to a test util library.
-    clear() {
-        this.data = {};
+    setStatus(_status) {
+        this.logger.warn('O11ySpan does not support setStatus.');
+        return this;
     }
-    delete(key, _options) {
-        delete this.data[key];
+    updateName(_name) {
+        this.logger.warn('O11ySpan does not support updateName.');
+        return this;
     }
-    get(key, _options) {
-        return this.data[key];
+    end(endTime) {
+        let endTimeInternal = endTime;
+        try {
+            if (typeof endTimeInternal !== 'number') {
+                this.logger.warn('O11ySpan does not support non number endTime override.');
+                endTimeInternal = undefined;
+            }
+            // TODO: Add support for stop schemas and data
+            this.activity.stop(undefined, undefined, endTimeInternal ? { perfStopOverride: endTimeInternal } : undefined);
+        }
+        finally {
+            this._isRecording = false;
+        }
+        return;
     }
-    set(key, value, _options) {
-        this.data[key] = value;
+    isRecording() {
+        return this._isRecording;
     }
-    length() {
-        return this.keys().length;
+    recordException(exception, _time) {
+        // TODO: Add support for exception schemas and data
+        this.activity.error(exception);
     }
-    keys() {
-        return new KeySetImpl(Object.keys(this.data));
+}
+
+class O11yOTelMetricsAPI {
+    constructor(services) {
+        this.services = services;
     }
-    toKeySet(keys) {
-        return new KeySetImpl(keys);
+    getMeter(name, 
+    // TODO: Not sure what to do with these?
+    _version, __options) {
+        const o11yInstrumentation = getInstrumentation(name);
+        return new O11yMeter(o11yInstrumentation, this.services.logger);
     }
 }
-/**
- * Constructs an in-memory implementation of StoreService.
- *
- * @returns in-memory implementation of StoreService
- */
-function buildInMemoryStoreService() {
-    return {
-        type: 'store',
-        version: '1.0',
-        service: new InMemoryStore(),
-    };
-}
-/**
- * A simple in-memory implementation of the MetadataRepository interface.
- *
- * Exported for testing purposes only.
- */
-class InMemoryMetadataRepository {
-    constructor() {
-        this.data = {};
+class O11yMeter {
+    constructor(o11yInstrumentation, logger) {
+        this.o11yInstrumentation = o11yInstrumentation;
+        this.logger = logger;
     }
-    // TODO - only intended for use in tests. We should refactor this into a subclass &
-    // add to a test util library.
-    clear() {
-        this.data = {};
+    createHistogram(name, _options) {
+        return new O11yHistogram(name, this.o11yInstrumentation, this.logger);
     }
-    delete(key, _options) {
-        delete this.data[key];
+    createCounter(name, options) {
+        if (options) {
+            this.logger.warn('counter options not supported in O11y instrumentation');
+        }
+        return new O11yCounter(name, this.o11yInstrumentation, this.logger);
     }
-    get(key, _options) {
-        return this.data[key];
+    createUpDownCounter(_name, _options) {
+        return new O11yUpDownCounter(this.logger);
     }
-    set(key, value, _options) {
-        this.data[key] = value;
+    createObservableGauge(_name, _options) {
+        return new O11yObservableGuage(this.logger);
     }
-    setPartial(key, value, _options) {
-        const metadata = this.get(key);
-        if (metadata === undefined) {
-            throw new Error(`Metadata for key "${key}" not found`);
-        }
-        this.data[key] = { ...metadata, ...value };
+    createObservableCounter(_name, _options) {
+        return new O11yObservableCounter(this.logger);
     }
-    expire(key, options) {
-        const { expirationTime = Date.now() } = options || {};
-        this.setPartial(key, { expirationTime });
+    createObservableUpDownCounter(_name, _options) {
+        return new O11yObservableUpDownCounter(this.logger);
+    }
+    addBatchObservableCallback(_callback, _observables) {
+        this.logger.warn('addBatchObservableCallback not supported yet');
+    }
+    removeBatchObservableCallback(_callback, _observables) {
+        this.logger.warn('removeBatchObservableCallback not supported yet');
     }
 }
-/**
- * Constructs an in-memory implementation of MetadataRepositoryService.
- *
- * @returns in-memory implementation of MetadataRepositoryService
- */
-function buildInMemoryMetadataRepositoryService() {
-    return {
-        type: 'metadataRepository',
-        version: '1.0',
-        service: new InMemoryMetadataRepository(),
-    };
-}
-
-/**
- * A RecordableStore wraps another Store and is used to record which keys in the
- * other Store are read/written.
- */
-class RecordableStore {
-    constructor(baseStore) {
-        this.baseStore = baseStore;
-        this.keysRead = new KeySetImpl();
-        this.missingKeysRead = new KeySetImpl();
-        this.keysUpdated = new KeySetImpl();
+class O11yCounter {
+    constructor(name, o11yInstrumentation, logger) {
+        this.name = name;
+        this.o11yInstrumentation = o11yInstrumentation;
+        this.logger = logger;
     }
-    delete(key, options) {
-        this.keysUpdated.add(key);
-        this.baseStore.delete(key, options);
+    add(value, _attributes, _context) {
+        if (value < 0) {
+            this.logger.warn(`Counter values must be non-negative. Got ${value}.`);
+            return;
+        }
+        this.o11yInstrumentation.incrementCounter(this.name, value);
     }
-    get(key, options) {
-        this.keysRead.add(key);
-        const value = this.baseStore.get(key, options);
-        if (value === undefined) {
-            this.missingKeysRead.add(key);
+}
+class O11yHistogram {
+    constructor(name, o11yInstrumentation, logger) {
+        this.name = name;
+        this.o11yInstrumentation = o11yInstrumentation;
+        this.logger = logger;
+    }
+    record(value, _attributes, _context) {
+        if (value < 0) {
+            this.logger.warn(`Histogram values must be non-negative. Got ${value}.`);
+            return;
         }
-        return value;
+        this.o11yInstrumentation.trackValue(this.name, value);
     }
-    set(key, value, options) {
-        this.keysUpdated.add(key);
-        this.baseStore.set(key, value, options);
+}
+class O11yUpDownCounter {
+    constructor(logger) {
+        this.logger = logger;
     }
-    length() {
-        return this.baseStore.length();
+    add(_value, _attributes, _context) {
+        this.logger.warn('O11yUpDownCounter not supported yet.');
     }
-    keys() {
-        return this.baseStore.keys();
+}
+class O11yObservableCounter {
+    constructor(logger) {
+        this.logger = logger;
     }
-    toKeySet(keys) {
-        return this.baseStore.toKeySet(keys);
+    addCallback(_callback) {
+        this.logger.warn('O11yObservableCounter not supported yet. Defaulting to noop.');
+    }
+    removeCallback(_callback) {
+        this.logger.warn('O11yObservableCounter not supported yet. Defaulting to noop.');
     }
 }
-
-/**
- * A TTLFilteredStore wraps another Store and filters data from that Store
- * to entries whose metadata indicates that it has not yet expired.
- */
-class TTLFilteredStore {
-    constructor(baseStore, metadataRepository, now = Date.now()) {
-        this.baseStore = baseStore;
-        this.metadataRepository = metadataRepository;
-        this.now = now;
-    }
-    delete(key, options) {
-        this.baseStore.delete(key, options);
-    }
-    get(key, options) {
-        const metadata = this.metadataRepository.get(key);
-        if (metadata && metadata.expirationTime <= this.now) {
-            return undefined;
-        }
-        return this.baseStore.get(key, options);
+class O11yObservableGuage {
+    constructor(logger) {
+        this.logger = logger;
     }
-    set(key, value, options) {
-        this.baseStore.set(key, value, options);
+    addCallback(_callback) {
+        this.logger.warn('O11yObservableGuage not supported yet. Defaulting to noop.');
     }
-    length() {
-        return this.keys().length;
+    removeCallback(_callback) {
+        this.logger.warn('O11yObservableGuage not supported yet. Defaulting to noop.');
     }
-    keys() {
-        return new KeySetImpl(this.baseStore
-            .keys()
-            .elements()
-            .filter((key) => this.get(key) !== undefined));
+}
+class O11yObservableUpDownCounter {
+    constructor(logger) {
+        this.logger = logger;
     }
-    toKeySet(keys) {
-        return this.baseStore.toKeySet(keys);
+    addCallback(_callback) {
+        this.logger.warn('O11yObservableUpDownCounter not supported yet. Defaulting to noop.');
+    }
+    removeCallback(_callback) {
+        this.logger.warn('O11yObservableUpDownCounter not supported yet. Defaulting to noop.');
     }
 }
 
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
-/**
- * Implementation of CacheInclusionPolicy that uses a single level, in memory,
- * synchronous L1 cache.
- */
-class InMemoryCacheInclusionPolicy {
-    /**
-     * Reads data out of a single level in memory store.
-     */
-    read(options) {
-        const { l1, readFromL1 } = options;
-        // l1 is all we've got
-        const readResult = readFromL1(l1);
-        return resolvedPromiseLike(readResult);
-    }
-    /**
-     * Writes data to a single level in memory store.
-     */
-    write(options) {
-        const { l1, writeToL1 } = options;
-        writeToL1(l1);
-        return resolvedPromiseLike(undefined);
+class O11yInstrumentation {
+    constructor(services) {
+        this.services = services;
+        this.trace = new O11yOTelTraceAPI(this.services);
+        this.metrics = new O11yOTelMetricsAPI(this.services);
     }
 }
-/**
- * Constructs an in-memory-only CacheInclusionPolicy.
- *
- * @returns in-memory-only CacheInclusionPolicy
- */
-function buildInMemoryCacheInclusionPolicyService() {
+function buildServiceDescriptor$4(logger) {
     return {
-        service: new InMemoryCacheInclusionPolicy(),
-        type: 'cacheInclusionPolicy',
+        type: 'instrumentation',
         version: '1.0',
+        service: new O11yInstrumentation({ logger }),
     };
 }
 
@@ -791,207 +771,106 @@ function buildInMemoryCacheInclusionPolicyService() {
  * For full license text, see the LICENSE.txt file
  */
 
-
-class CacheThenNetworkPolicy {
-    constructor(services, validator) {
-        this.services = services;
-        this.validator = validator;
-        this.policyName = 'cache-then-network';
-    }
-    run(options) {
-        const { readFromCache: readFromCacheOriginal, readFromNetwork: readFromNetworkOriginal, writeToCache: writeToCacheOriginal, buildResult, } = options;
-        // filter what data readFromCache is allowed to access from the store
-        const now = Date.now();
-        let ttlStore = new TTLFilteredStore(this.services.store, this.services.metadataRepository, now);
-        const { readFromCache: readFromCacheDedupe, readFromNetwork: readFromNetworkDedupe, writeToCache: writeToCacheDedupe, } = this.services.requestDedupe.applyDedupe({
-            readFromCache: (services) => this.readWithValidation(() => readFromCacheOriginal(services)),
-            readFromNetwork: readFromNetworkOriginal,
-            writeToCache: (services, networkResult) => this.writeWithValidation(() => writeToCacheOriginal(networkResult, services)),
-        });
-        return readFromCacheDedupe({ ...this.services, store: ttlStore }).then((value) => {
-            if (isCacheHitOrError(value)) {
-                return value;
-            }
-            // result not found in cache, try network
-            return readFromNetworkDedupe()
-                .then((value) => {
-                return writeToCacheDedupe(this.services, value).then(() => value);
-            })
-                .then((value) => {
-                const builtResult = buildResult(value, this.services);
-                this.validator.validateBuildResult(builtResult);
-                return builtResult;
-            });
-        });
-    }
-    readWithValidation(readFromCache) {
-        const readResult = readFromCache();
-        this.validator.validateReadResult(readResult);
-        return readResult;
-    }
-    writeWithValidation(writeToCache) {
-        const writeResult = writeToCache();
-        this.validator.validateWriteResult(writeResult);
-        return writeResult;
-    }
-}
-function buildCacheThenNetworkPolicy(services, validator) {
-    return new CacheThenNetworkPolicy(services, validator);
-}
-
 /**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
+ * A collection of keys, in no particular order.
  */
-
-class NoopOTelTraceAPI {
-    getTracer(_name, _version, _options) {
-        return new NoopTracer();
-    }
-}
-class NoopTracer {
-    startSpan(_name, _options, _context) {
-        return new NoopSpan();
-    }
-    startActiveSpan(name, options, context, fn) {
-        let opts;
-        let ctx;
-        let fun;
-        if (typeof options === 'function') {
-            fun = options;
-        }
-        else {
-            opts = options;
-            if (typeof context === 'function') {
-                fun = context;
-            }
-            else {
-                ctx = context;
-                fun = fn;
-            }
-        }
-        const span = this.startSpan(name, opts, ctx);
-        try {
-            return fun(span);
-        }
-        finally {
-            span.end();
+class KeySetImpl {
+    constructor(initialKeys) {
+        // TODO - probably better to use Set<Key>
+        this.data = {};
+        this.lengthInternal = 0;
+        if (initialKeys) {
+            initialKeys.forEach((key) => {
+                this.add(key);
+            });
         }
     }
-}
-class NoopSpan {
-    spanContext() {
-        // TODO: I'll need to double check, but I think even if we provide a
-        // noop implementation, there is still a requirement to pass along context
-        return {
-            spanId: 'noopSpanId',
-            traceId: 'noopTraceId',
-            traceFlags: 0,
-        };
-    }
-    setAttribute(_key, _value) {
-        return this;
-    }
-    setAttributes(_attributes) {
-        return this;
-    }
-    addEvent(_name, _attributesOrStartTime, _startTime) {
-        return this;
-    }
-    setStatus(_status) {
-        return this;
-    }
-    updateName(_name) {
-        return this;
-    }
-    end(_endTime) {
-        return;
-    }
-    isRecording() {
-        return false;
-    }
-    recordException(_exception, _time) {
-        return;
-    }
-}
-
-class NoopOTelMetricsAPI {
-    getMeter(__name, _version, __options) {
-        return new NoopMeter();
-    }
-}
-class NoopMeter {
-    createHistogram(_name, _options) {
-        return new NoopHistogram();
+    add(key) {
+        this.data[key] = true;
+        // TODO - need to account for adding a key that was already in the set
+        this.lengthInternal++;
     }
-    createCounter(_name, _options) {
-        return new NoopCounter();
+    contains(key) {
+        return this.data[key] === true;
     }
-    createUpDownCounter(_name, _options) {
-        return new NoopUpDownCounter();
+    elements() {
+        return Object.keys(this.data);
     }
-    createObservableGauge(_name, _options) {
-        return new NoopObservableGuage();
+    get length() {
+        return this.lengthInternal;
     }
-    createObservableCounter(_name, _options) {
-        return new NoopObservableCounter();
+    overlaps(other) {
+        const otherKeys = other.elements();
+        for (let j = 0; j < otherKeys.length; ++j) {
+            if (this.contains(otherKeys[j])) {
+                return true;
+            }
+        }
+        return false;
     }
-    createObservableUpDownCounter(_name, _options) {
-        return new NoopObservableUpDownCounter();
+    difference(other) {
+        const value = new KeySetImpl();
+        this.elements().forEach((key) => {
+            if (!other.contains(key)) {
+                value.add(key);
+            }
+        });
+        return value;
     }
-    addBatchObservableCallback(_callback, _observables) {
-        return;
+    isSubsetOf(other) {
+        return this.difference(other).length === 0;
     }
-    removeBatchObservableCallback(_callback, _observables) {
-        return;
+    equals(other) {
+        return this.length === other.length && this.elements().every((key) => other.contains(key));
     }
-}
-class NoopCounter {
-    add(_value, _attributes, _context) {
-        return;
+    toString() {
+        return `<<${JSON.stringify(this.elements())}>>`;
     }
 }
-class NoopHistogram {
-    record(_value, _attributes, _context) {
-        return;
+
+/**
+ * A simple in-memory implementation of the Store interface.
+ *
+ * Exported for testing purposes only.
+ */
+class InMemoryStore {
+    constructor() {
+        this.data = {};
     }
-}
-class NoopUpDownCounter {
-    add(_value, _attributes, _context) {
-        return;
+    // TODO - only intended for use in tests. We should refactor this into a subclass &
+    // add to a test util library.
+    clear() {
+        this.data = {};
     }
-}
-class NoopObservableCounter {
-    addCallback(_callback) {
-        return;
+    delete(key, _options) {
+        delete this.data[key];
     }
-    removeCallback(_callback) {
-        return;
+    get(key, _options) {
+        return this.data[key];
     }
-}
-class NoopObservableGuage {
-    addCallback(_callback) {
-        return;
+    set(key, value, _options) {
+        this.data[key] = value;
     }
-    removeCallback(_callback) {
-        return;
+    length() {
+        return this.keys().length;
     }
-}
-class NoopObservableUpDownCounter {
-    addCallback(_callback) {
-        return;
+    keys() {
+        return new KeySetImpl(Object.keys(this.data));
     }
-    removeCallback(_callback) {
-        return;
+    toKeySet(keys) {
+        return new KeySetImpl(keys);
     }
 }
-
-/* eslint-disable no-dupe-class-members */
-function buildNoopInstrumentationService() {
+/**
+ * Constructs an in-memory implementation of StoreService.
+ *
+ * @returns in-memory implementation of StoreService
+ */
+function buildServiceDescriptor$3() {
     return {
-        trace: new NoopOTelTraceAPI(),
-        metrics: new NoopOTelMetricsAPI(),
+        type: 'store',
+        version: '1.0',
+        service: new InMemoryStore(),
     };
 }
 
@@ -1002,120 +881,92 @@ function buildNoopInstrumentationService() {
  */
 
 
+class DefaultCache {
+    constructor(services) {
+        this.services = services;
+    }
+    /**
+     * Returns the cache entry at the specified key; undefined if no
+     * such entry exists.
+     *
+     * @param key store key
+     */
+    get(key) {
+        return this.services.store.get(key);
+    }
+    /**
+     * Adds the specified key/value to the cache.
+     *
+     * @param key key at which to store value
+     * @param entry value to be stored
+     */
+    set(key, entry) {
+        if (entry.cacheControlMetadata.type === 'no-store') {
+            return;
+        }
+        return this.services.store.set(key, entry);
+    }
+    /**
+     * Removes the cache entry associated with the specified key.
+     *
+     * @param key key to be removed from the store
+     */
+    delete(key) {
+        this.services.store.delete(key);
+    }
+    length() {
+        return this.services.store.length();
+    }
+    keys() {
+        return this.services.store.keys();
+    }
+    toKeySet(keys) {
+        return this.services.store.toKeySet(keys);
+    }
+}
+
 /**
- * Exported for testing purposes only
+ A utility class for recording actions made on a cache.
  */
-class KeyBasedRequestDedupe {
-    constructor() {
-        // TODO [W-12965475]: This class is a first pass at network deduplication. No consuming Commands should
-        // directly try to leverage this, as it will be refactored/removed in the future.
-        // This map tracks the mapping of the key set a given network request response is expected to contain
-        // to that network request's outstanding promise. Entries are added to this map when a request has
-        // a set of expected keys, and a new network request promise is created.
-        this.outstandingNetworkRequests = new Map();
-        // This map tracks the mapping of the keys a given read is waiting for to a resolve function that notifies the read
-        // that the keys it needs may now be present in the cache. This resolve function can be called when any network
-        // response is ingested, and the ingested keys contain the keys the read needs. This map is added to when
-        // we believe that an outstanding request may contain the keys needed to satisfy a read.
-        this.outstandingReads = new Map();
-    }
-    applyDedupe({ readFromCache, readFromNetwork, writeToCache, }) {
-        const closureVariables = { expectedNetworkKeys: undefined };
-        return {
-            readFromCache: this.buildDedupedReadFromCache(readFromCache, closureVariables),
-            readFromNetwork: this.buildDedupedReadFromNetwork(readFromNetwork, closureVariables),
-            writeToCache: this.buildDedupedWriteToCache(writeToCache),
-        };
+class RecordableCache {
+    constructor(baseCache) {
+        this.baseCache = baseCache;
+        this.keysRead = new KeySetImpl();
+        this.missingKeysRead = new KeySetImpl();
+        this.keysUpdated = new KeySetImpl();
     }
-    buildDedupedReadFromCache(readFromCache, closureVariables) {
-        const dedupedReadFromCache = (services) => {
-            const recordableStore = new RecordableStore(services.store);
-            return readFromCache({ ...services, store: recordableStore }).then((value) => {
-                const missingKeys = recordableStore.missingKeysRead;
-                // if cache result was final, or we got a cache miss even though
-                // we don't recognize anything as missing then we're done
-                if (isCacheHitOrError(value) || missingKeys.length === 0) {
-                    return value;
-                }
-                // if we end up making a network request, we expect that it will return
-                // everything that was initially missing
-                if (!closureVariables.expectedNetworkKeys) {
-                    closureVariables.expectedNetworkKeys = missingKeys;
-                }
-                // build a list of the Promises for all the outstanding network requests
-                // that are expected to return at least one of our missing keys
-                let unrequestedKeys = services.store.toKeySet(missingKeys.elements());
-                const matchingRequests = Array.from(this.outstandingNetworkRequests.entries()).reduce((matches, [outstandingRequestKeys, promise]) => {
-                    if (outstandingRequestKeys.overlaps(missingKeys)) {
-                        matches.push(promise);
-                        unrequestedKeys = unrequestedKeys.difference(outstandingRequestKeys);
-                    }
-                    return matches;
-                }, []);
-                // if outstanding requests are not expected to return all the keys we need,
-                // return the cache read result
-                if (unrequestedKeys.length > 0) {
-                    return value;
-                }
-                // Create a promise that can be resolved if any outstanding requests satisfy
-                // the missing keys
-                const otherResultMatchesPromise = new Promise((resolve) => {
-                    this.outstandingReads.set(closureVariables.expectedNetworkKeys, resolve);
-                });
-                // wait for one of the matching network requests to come back, then retry
-                return Promise.race([otherResultMatchesPromise, ...matchingRequests])
-                    .then(() => {
-                    this.outstandingReads.delete(closureVariables.expectedNetworkKeys);
-                    return dedupedReadFromCache(services);
-                })
-                    .catch(() => {
-                    this.outstandingReads.delete(closureVariables.expectedNetworkKeys);
-                    return dedupedReadFromCache(services);
-                });
-            });
-        };
-        return dedupedReadFromCache;
+    delete(key) {
+        this.keysUpdated.add(key);
+        this.baseCache.delete(key);
     }
-    buildDedupedReadFromNetwork(readFromNetwork, closureVariables) {
-        return () => {
-            if (closureVariables.expectedNetworkKeys === undefined ||
-                closureVariables.expectedNetworkKeys.length === 0) {
-                return readFromNetwork();
-            }
-            const deleteOutstandingRequest = () => this.outstandingNetworkRequests.delete(closureVariables.expectedNetworkKeys);
-            const networkPromise = readFromNetwork().then((value) => {
-                deleteOutstandingRequest();
-                return value;
-            }, (reason) => {
-                deleteOutstandingRequest();
-                return new Promise((_resolve, rejects) => {
-                    rejects(reason);
-                });
-            });
-            this.outstandingNetworkRequests.set(closureVariables.expectedNetworkKeys, networkPromise);
-            return networkPromise;
-        };
+    get(key) {
+        this.keysRead.add(key);
+        const value = this.baseCache.get(key);
+        if (value === undefined) {
+            this.missingKeysRead.add(key);
+        }
+        return value;
     }
-    buildDedupedWriteToCache(writeToCache) {
-        return (services, networkResult) => {
-            const recordableStore = new RecordableStore(services.store);
-            const result = writeToCache({ ...services, store: recordableStore }, networkResult);
-            return result.then(() => {
-                const updatedKeys = recordableStore.keysUpdated;
-                Array.from(this.outstandingReads.entries()).forEach(([outstandingReadKeys, resolve]) => {
-                    if (outstandingReadKeys.isSubsetOf(updatedKeys)) {
-                        resolve();
-                    }
-                });
-            });
-        };
+    set(key, value) {
+        this.keysUpdated.add(key);
+        this.baseCache.set(key, value);
+    }
+    length() {
+        return this.baseCache.length();
+    }
+    keys() {
+        return this.baseCache.keys();
+    }
+    toKeySet(keys) {
+        return this.baseCache.toKeySet(keys);
     }
 }
-function buildKeyBasedRequestDedupeService() {
+
+function buildServiceDescriptor$2(store) {
     return {
-        type: 'requestDedupe',
+        type: 'cache',
         version: '1.0',
-        service: new KeyBasedRequestDedupe(),
+        service: new DefaultCache({ store }),
     };
 }
 
@@ -1127,87 +978,148 @@ function buildKeyBasedRequestDedupeService() {
 
 
 /**
- * A simple implementation of KeyKeySubscriptionService.
+ * A utility class for adapting a cache to a TypeStore.
+ *
+ * This allows command code to write to a cache without having
+ * to know about cache control metadata.
  */
-class DefaultKeySubscriptionService {
-    constructor() {
-        this.nextId = 1;
-        this.subscriptions = [];
+class CacheControlTypeStoreAdapter {
+    constructor(cache, cacheControlMetadata = undefined) {
+        this.cache = cache;
+        this.cacheControlMetadata = cacheControlMetadata;
     }
-    subscribe(options) {
-        const subscriptionId = this.nextId++;
-        const { subscription, callback } = options;
-        this.subscriptions.push({ subscriptionId, keys: subscription, callback });
-        return () => {
-            this.subscriptions = this.subscriptions.filter((subscription) => subscription.subscriptionId !== subscriptionId);
-        };
+    get(key) {
+        return this.cache.get(key);
     }
-    publish(keys, _options) {
-        const subscriptions = this.subscriptions.slice();
-        for (let i = 0; i < subscriptions.length; ++i) {
-            const { keys: subscriptionKeys, callback } = subscriptions[i];
-            if (keys.overlaps(subscriptionKeys)) {
-                callback();
-            }
+    set(key, value) {
+        if (this.cacheControlMetadata === undefined) {
+            throw new Error('Cache control metadata is undefined');
         }
-        return resolvedPromiseLike(undefined);
+        return this.cache.set(key, {
+            ...value,
+            cacheControlMetadata: this.cacheControlMetadata,
+        });
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    length() {
+        return this.cache.length();
+    }
+    keys() {
+        return this.cache.keys();
+    }
+    toKeySet(keys) {
+        return this.cache.toKeySet(keys);
     }
 }
-/**
- * Constructs a default KeySubscriptionService
- *
- * @returns default KeySubscriptionService
- */
-function buildDefaultKeySubscriptionService() {
-    return {
-        type: 'keySubscription',
-        version: '1.0',
-        service: new DefaultKeySubscriptionService(),
-    };
+
+class CacheControlStrategy {
+    constructor(services, config, buildRequestRunnerProxy) {
+        this.services = services;
+        this.config = config;
+        this.recordableCache = new RecordableCache(this.services.cache);
+        this.recordableMaxAgeTypeStore = new CacheControlTypeStoreAdapter(this.recordableCache);
+        this.requestRunnerProxy = buildRequestRunnerProxy(this.recordableMaxAgeTypeStore);
+    }
+    isCacheHit(cacheReadValue) {
+        const isCacheMiss = cacheReadValue.isErr() ||
+            cacheReadValue.value === undefined ||
+            this.areUsedCacheEntriesExpired();
+        return !isCacheMiss;
+    }
+    get expiredChecks() {
+        return [
+            (cacheControlMetadata) => cacheControlMetadata.type === 'max-age' &&
+                this.config.now > cacheControlMetadata.generatedTime + cacheControlMetadata.maxAge,
+            (cacheControlMetadata) => cacheControlMetadata.type === 'no-cache' ||
+                cacheControlMetadata.type === 'no-store',
+        ];
+    }
+    areUsedCacheEntriesExpired() {
+        return this.recordableCache.keysRead.elements().some((key) => {
+            const entry = this.recordableCache.get(key);
+            if (entry === undefined) {
+                // Not sure how this would be possible, but we'll just say it's expired
+                return true;
+            }
+            const { cacheControlMetadata } = entry;
+            return this.expiredChecks.some((check) => check(cacheControlMetadata));
+        });
+    }
+}
+
+class MaxAgeCacheControlStrategy extends CacheControlStrategy {
+    execute() {
+        return this.requestRunnerProxy.readFromCache().then((value) => {
+            if (this.isCacheHit(value)) {
+                return value;
+            }
+            return this.handleCacheMiss();
+        });
+    }
+    handleCacheMiss() {
+        let error;
+        return this.requestRunnerProxy
+            .requestFromNetwork()
+            .then((value) => {
+            if (value.isErr()) {
+                error = value;
+                return resolvedPromiseLike(null);
+            }
+            this.recordableMaxAgeTypeStore.cacheControlMetadata =
+                value.value.cacheControlMetadata;
+            return this.requestRunnerProxy.writeToCache(ok(value.value.networkResponse));
+        })
+            .then(() => {
+            if (error) {
+                return resolvedPromiseLike(null);
+            }
+            return this.requestRunnerProxy.readFromCache();
+        })
+            .then((value) => {
+            if (value === null) {
+                return error;
+            }
+            if (!this.isCacheHit(value)) {
+                return err(new Error('Cache miss after fetching from network'));
+            }
+            return value;
+        });
+    }
+    get expiredChecks() {
+        return [
+            ...super.expiredChecks,
+            (cacheControlMetadata) => cacheControlMetadata.generatedTime + this.config.requestMaxAge < this.config.now,
+        ];
+    }
 }
 
 /**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
+ * A class that allows the execution of requested cache control strategies,
+ * while also enforcing the canonical cache control metadata.
  */
-
-
-class DefaultTypeNotFoundError extends Error {
-}
-class DefaultTypeRegistry {
-    constructor() {
-        this.registry = {};
-        this.TypeNotFoundError = DefaultTypeNotFoundError;
+class CacheController {
+    constructor(services) {
+        this.services = services;
     }
-    register(type, _options) {
-        if (!this.registry[type.namespace]) {
-            this.registry[type.namespace] = {};
-        }
-        this.registry[type.namespace][type.typeName] = type;
+    execute(config, buildRequestRunnerProxy) {
+        const strategy = this.getCacheControlStrategy(config, buildRequestRunnerProxy);
+        return strategy.execute();
     }
-    get(namespace, typeName, _options) {
-        const registryNamespace = this.registry[namespace];
-        if (!registryNamespace) {
-            throw new DefaultTypeNotFoundError(`namespace ${namespace} not found`);
-        }
-        const type = registryNamespace[typeName];
-        if (!type) {
-            throw new DefaultTypeNotFoundError(`type ${typeName} not found in namespace ${namespace}`);
+    getCacheControlStrategy(config, buildRequestRunnerProxy) {
+        if (config.type === 'max-age') {
+            return new MaxAgeCacheControlStrategy(this.services, config, buildRequestRunnerProxy);
         }
-        return type;
+        throw new Error(`Unknown cache control strategy ${config.type}`);
     }
 }
-/**
- * Constructs an in-memory implementation of StoreService.
- *
- * @returns in-memory implementation of StoreService
- */
-function buildDefaultTypeRegistryService() {
+
+function buildServiceDescriptor$1(cache) {
     return {
-        type: 'typeRegistry',
+        type: 'cacheControl',
         version: '1.0',
-        service: new DefaultTypeRegistry(),
+        service: new CacheController({ cache }),
     };
 }
 
@@ -1217,7 +1129,7 @@ function buildDefaultTypeRegistryService() {
  * For full license text, see the LICENSE.txt file
  */
 
-function e$1(e){this.message=e;}e$1.prototype=new Error,e$1.prototype.name="InvalidCharacterError";var r$1="undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e$1("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function t$1(e){var t=e.replace(/-/g,"+").replace(/_/g,"/");switch(t.length%4){case 0:break;case 2:t+="==";break;case 3:t+="=";break;default:throw "Illegal base64url string!"}try{return function(e){return decodeURIComponent(r$1(e).replace(/(.)/g,(function(e,r){var t=r.charCodeAt(0).toString(16).toUpperCase();return t.length<2&&(t="0"+t),"%"+t})))}(t)}catch(e){return r$1(t)}}function n$1(e){this.message=e;}function o$1(e,r){if("string"!=typeof e)throw new n$1("Invalid token specified");var o=!0===(r=r||{}).header?0:1;try{return JSON.parse(t$1(e.split(".")[o]))}catch(e){throw new n$1("Invalid token specified: "+e.message)}}n$1.prototype=new Error,n$1.prototype.name="InvalidTokenError";
+function e$1(e){this.message=e;}e$1.prototype=new Error,e$1.prototype.name="InvalidCharacterError";var r="undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e$1("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function t(e){var t=e.replace(/-/g,"+").replace(/_/g,"/");switch(t.length%4){case 0:break;case 2:t+="==";break;case 3:t+="=";break;default:throw "Illegal base64url string!"}try{return function(e){return decodeURIComponent(r(e).replace(/(.)/g,(function(e,r){var t=r.charCodeAt(0).toString(16).toUpperCase();return t.length<2&&(t="0"+t),"%"+t})))}(t)}catch(e){return r(t)}}function n$1(e){this.message=e;}function o(e,r){if("string"!=typeof e)throw new n$1("Invalid token specified");var o=!0===(r=r||{}).header?0:1;try{return JSON.parse(t(e.split(".")[o]))}catch(e){throw new n$1("Invalid token specified: "+e.message)}}n$1.prototype=new Error,n$1.prototype.name="InvalidTokenError";
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -1357,7 +1269,7 @@ if (process.env.NODE_ENV !== 'production') {
  * @returns An object of decoded JWT token information.
  */
 function computeDecodedInfo(token, defaultTokenTTLInSeconds, logger) {
-    const decodedInfo = o$1(token);
+    const decodedInfo = o(token);
     if (decodedInfo.exp === undefined) {
         logger.warn(`"exp" claim is not present in the provided token.`);
         decodedInfo.exp = Date.now() / 1000 + defaultTokenTTLInSeconds;
@@ -1541,7 +1453,7 @@ class JwtManager {
  */
 
 
-function buildFetchService(interceptors = { request: [] }) {
+function buildServiceDescriptor(interceptors = { request: [] }) {
     return {
         type: 'fetch',
         version: '1.0',
@@ -1712,10 +1624,10 @@ const composedNetworkAdapter$1 = {
     adapter: sfapNetworkAdapter,
 };
 
-function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";var r="undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function t(e){var t=e.replace(/-/g,"+").replace(/_/g,"/");switch(t.length%4){case 0:break;case 2:t+="==";break;case 3:t+="=";break;default:throw "Illegal base64url string!"}try{return function(e){return decodeURIComponent(r(e).replace(/(.)/g,(function(e,r){var t=r.charCodeAt(0).toString(16).toUpperCase();return t.length<2&&(t="0"+t),"%"+t})))}(t)}catch(e){return r(t)}}function n(e){this.message=e;}function o(e,r){if("string"!=typeof e)throw new n("Invalid token specified");var o=!0===(r=r||{}).header?0:1;try{return JSON.parse(t(e.split(".")[o]))}catch(e){throw new n("Invalid token specified: "+e.message)}}n.prototype=new Error,n.prototype.name="InvalidTokenError";
+function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";"undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function n(e){this.message=e;}n.prototype=new Error,n.prototype.name="InvalidTokenError";
 
 const SFAP_BASE_URL = 'api.salesforce.com';
-function buildJwtAuthorizedSfapFetchService(logger) {
+function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
     const jwtRepository = new JwtRepository();
     const jwtManager = new JwtManager(jwtRepository, platformSfapJwtResolver);
     const jwtRequestModifier = ({ baseUri }, [resource, request]) => {
@@ -1737,52 +1649,16 @@ function buildJwtAuthorizedSfapFetchService(logger) {
         return [url, request];
     };
     const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier);
-    const jwtAuthorizedFetchService = buildFetchService({ request: [jwtRequestHeaderInterceptor] });
+    const jwtAuthorizedFetchService = buildServiceDescriptor({
+        request: [jwtRequestHeaderInterceptor],
+    });
     return {
         ...jwtAuthorizedFetchService,
         tags: { authenticationScopes: 'sfap_api' },
     };
 }
-const lightningJwtResolver = {
-    getJwt() {
-        // JWT Manager should be updated to use promise like instead of promise to accomadate use cases like this
-        return resolvedPromiseLike(window.$A.clientService.getJwtAuthToken()).then((jwt) => {
-            const baseUri = o(jwt.jwt).iss;
-            return {
-                jwt: jwt.jwt,
-                extraInfo: { baseUri },
-            };
-        });
-    },
-};
-function buildJwtAuthorizedLightningFetchService() {
-    const jwtRepository = new JwtRepository();
-    const jwtManager = new JwtManager(jwtRepository, lightningJwtResolver);
-    const jwtRequestModifier = ({ baseUri }, [resource, request]) => {
-        if (typeof resource !== 'string' && !(resource instanceof URL)) {
-            // istanbul ignore else: this will not be tested in NODE_ENV = production for test coverage
-            if (process.env.NODE_ENV !== 'production') {
-                throw new Error('Lightning fetch service expects a string or URL resource');
-            }
-            return [resource, request];
-        }
-        const url = typeof resource === 'string'
-            ? new URL(resource, 'https://lightning.salesforce.com')
-            : new URL(resource.toString());
-        const overrideUrl = new URL(baseUri);
-        url.host = overrideUrl.host;
-        url.protocol = overrideUrl.protocol;
-        return [url, request];
-    };
-    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier);
-    const jwtAuthorizedFetchService = buildFetchService({ request: [jwtRequestHeaderInterceptor] });
-    return {
-        ...jwtAuthorizedFetchService,
-        tags: { authenticationScopes: 'lightning_api' },
-    };
-}
-function buildUnauthorizedFetchService() {
-    const fetchService = buildFetchService();
+function buildUnauthorizedFetchServiceDescriptor() {
+    const fetchService = buildServiceDescriptor();
     return {
         ...fetchService,
         tags: { authenticationScopes: '' },
@@ -4249,7 +4125,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.316.0-4453f1e2b6
+// version: 1.318.0-46c39b8717
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -4901,58 +4777,22 @@ function initializeLDS() {
 }
 // Initializes OneStore in LEX
 function initializeOneStore() {
-    const validator = {
-        validateReadResult() { },
-        validateWriteResult() { },
-        validateBuildResult() { },
-    };
-    const keySubscriptionServiceDescriptor = buildDefaultKeySubscriptionService();
-    const metadataRepositoryServiceDescriptor = buildInMemoryMetadataRepositoryService();
-    const storeServiceDescriptor = buildInMemoryStoreService();
-    const requestDedupeServiceDescriptor = buildKeyBasedRequestDedupeService();
-    const cachePolicyServiceDescriptor = {
-        type: 'cachePolicy',
-        version: '1.0',
-        service: {
-            cachePolicies: [
-                buildCacheThenNetworkPolicy({
-                    keySubscription: keySubscriptionServiceDescriptor.service,
-                    metadataRepository: metadataRepositoryServiceDescriptor.service,
-                    requestDedupe: requestDedupeServiceDescriptor.service,
-                    store: storeServiceDescriptor.service,
-                }, validator),
-            ],
-            defaultCachePolicyName: 'cache-then-network',
-        },
-    };
-    // TODO [W-1234567]: Export descriptor builder for o11y and noop instrumentaiton
-    const instrumentationServiceDescriptor = {
-        type: 'instrumentation',
-        version: '1.0',
-        service: buildNoopInstrumentationService(),
-    };
     const loggerService = new ConsoleLogger$1('ERROR');
+    const storeServiceDescriptor = buildServiceDescriptor$3();
+    const cacheServiceDescriptor = buildServiceDescriptor$2(storeServiceDescriptor.service);
+    const instrumentationServiceDescriptor = buildServiceDescriptor$4(loggerService);
     const services = [
-        buildUnauthorizedFetchService(),
-        buildJwtAuthorizedSfapFetchService(loggerService),
-        buildJwtAuthorizedLightningFetchService(),
-        keySubscriptionServiceDescriptor,
-        metadataRepositoryServiceDescriptor,
-        storeServiceDescriptor,
-        requestDedupeServiceDescriptor,
-        cachePolicyServiceDescriptor,
-        buildDefaultTypeRegistryService(),
-        buildAuraNetworkService(),
-        buildInMemoryCacheInclusionPolicyService(),
-        buildAuraNetworkCommandBaseClassService(),
-        buildFetchNetworkCommandBaseClassService(),
-        buildNetworkCommandBaseClassService(),
-        buildStreamingCommandBaseClassService(),
-        buildSSECommandBaseClassService(),
         instrumentationServiceDescriptor,
-        buildInstrumentCommandServiceDescriptor({
-            instrumentation: instrumentationServiceDescriptor.service,
-        }),
+        buildUnauthorizedFetchServiceDescriptor(),
+        buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
+        buildAuraNetworkService(),
+        buildServiceDescriptor$5(instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$1(cacheServiceDescriptor.service),
+        buildServiceDescriptor$9(),
+        buildServiceDescriptor$8(),
+        buildServiceDescriptor$a(),
+        buildServiceDescriptor$7(),
+        buildServiceDescriptor$6(),
     ];
     serviceBroker.publish(services);
 }
@@ -4981,4 +4821,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.316.0-fd56ed976d
+// version: 1.318.0-5cd8dfe184