@salesforce/lds-runtime-webruntime 1.360.0

package/dist/webruntimeOneRuntimeInit.js

@@ -0,0 +1,2909 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { getInstrumentation } from 'o11y/client';
+import { setServices } from 'force/luvioServiceProvisioner1';
+import { executeGlobalControllerRawResponse } from 'aura';
+import { HttpStatusCode as HttpStatusCode$2 } from 'force/luvioEngine';
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+const { create, freeze, keys, entries } = Object;
+const { isArray } = Array;
+const { stringify, parse } = JSON;
+
+const LogLevelMap$1 = {
+    TRACE: 4,
+    DEBUG: 3,
+    INFO: 2,
+    WARN: 1,
+    ERROR: 0,
+};
+/**
+ * A simple Logger implementation.
+ */
+let ConsoleLogger$1 = class ConsoleLogger {
+    constructor(level = 'WARN', 
+    // eslint-disable-next-line no-console
+    printer = console.log, formatter = (level, message) => `${level}: ${message}`) {
+        this.level = level;
+        this.printer = printer;
+        this.formatter = formatter;
+        this.messages = [];
+    }
+    trace(message) {
+        this.log('TRACE', message);
+    }
+    debug(message) {
+        this.log('DEBUG', message);
+    }
+    info(message) {
+        this.log('INFO', message);
+    }
+    warn(message) {
+        this.log('WARN', message);
+    }
+    error(message) {
+        this.log('ERROR', message);
+    }
+    log(level, message) {
+        if (LogLevelMap$1[level] > LogLevelMap$1[this.level]) {
+            return;
+        }
+        this.printer(this.formatter(level, message));
+    }
+};
+
+class Ok {
+    constructor(value) {
+        this.value = value;
+    }
+    isOk() {
+        return true;
+    }
+    isErr() {
+        return !this.isOk();
+    }
+}
+class Err {
+    constructor(error) {
+        this.error = error;
+    }
+    isOk() {
+        return false;
+    }
+    isErr() {
+        return !this.isOk();
+    }
+}
+const ok = (value) => new Ok(value);
+const err = (err) => new Err(err);
+function isSubscribableResult(x) {
+    if (typeof x !== 'object' || x === null) {
+        return false;
+    }
+    if ('isOk' in x && typeof x.isOk === 'function') {
+        if (x.isOk()) {
+            return ('value' in x &&
+                typeof x.value === 'object' &&
+                x.value !== null &&
+                'subscribe' in x.value &&
+                typeof x.value.subscribe === 'function' &&
+                'refresh' in x.value &&
+                typeof x.value.refresh === 'function');
+        }
+        else {
+            return 'error' in x;
+        }
+    }
+    return false;
+}
+
+/**
+ * Returns a PromiseLike object that resolves with the specified result.
+ *
+ * @param result resolved result
+ * @returns
+ */
+function resolvedPromiseLike(result) {
+    // Don't nest anything promise like
+    if (isPromiseLike(result)) {
+        return result.then((nextResult) => nextResult);
+    }
+    return {
+        then: (onFulfilled, _onRejected) => {
+            if (typeof onFulfilled === 'function') {
+                try {
+                    return resolvedPromiseLike(onFulfilled(result));
+                }
+                catch (e) {
+                    return rejectedPromiseLike(e);
+                }
+            }
+            // assume TResult1 == Result and just pass result down the chain
+            return resolvedPromiseLike(result);
+        },
+    };
+}
+/**
+ * Returns a PromiseLike object that rejects with the specified reason.
+ *
+ * @param reason rejection value
+ * @returns PromiseLike that rejects with reason
+ */
+function rejectedPromiseLike(reason) {
+    if (isPromiseLike(reason)) {
+        return reason.then((nextResult) => nextResult);
+    }
+    return {
+        then: (_onFulfilled, onRejected) => {
+            if (typeof onRejected === 'function') {
+                try {
+                    return resolvedPromiseLike(onRejected(reason));
+                }
+                catch (e) {
+                    return rejectedPromiseLike(e);
+                }
+            }
+            // assume TResult2 == Result and just pass rejection down the chain
+            return rejectedPromiseLike(reason);
+        },
+    };
+}
+/**
+ * Indicates if an object is PromiseLike.
+ *
+ * @param x anything
+ * @returns true if x is PromiseLike; false if not
+ */
+function isPromiseLike(x) {
+    return typeof x === 'object' && typeof (x === null || x === void 0 ? void 0 : x.then) === 'function';
+}
+
+/**
+ * Recursively compares two values and indicates if they are equal.
+ *
+ * @param x first value
+ * @param y second value
+ * @returns true if x and y are recursively equal to each other; false if not
+ */
+function deepEquals(x, y) {
+    if (x === undefined) {
+        return y === undefined;
+    }
+    else if (x === null) {
+        return y === null;
+    }
+    else if (y === null) {
+        return x === null;
+    }
+    else if (isArray(x)) {
+        if (!isArray(y) || x.length !== y.length) {
+            return false;
+        }
+        for (let i = 0; i < x.length; ++i) {
+            if (!deepEquals(x[i], y[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (typeof x === 'object') {
+        if (typeof y !== 'object') {
+            return false;
+        }
+        const xkeys = Object.keys(x);
+        const ykeys = Object.keys(y);
+        if (xkeys.length !== ykeys.length) {
+            return false;
+        }
+        for (let i = 0; i < xkeys.length; ++i) {
+            const key = xkeys[i];
+            if (!deepEquals(x[key], y[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return x === y;
+}
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+function stableJSONStringify(node) {
+    // This is for Date values.
+    if (node && node.toJSON && typeof node.toJSON === 'function') {
+        // eslint-disable-next-line no-param-reassign
+        node = node.toJSON();
+    }
+    if (node === undefined) {
+        return;
+    }
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
+    }
+    if (typeof node !== 'object') {
+        return stringify(node);
+    }
+    let i;
+    let out;
+    if (isArray(node)) {
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify(node[i]) || 'null';
+        }
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const objKeys = keys(node).sort();
+    out = '';
+    for (i = 0; i < objKeys.length; i++) {
+        const key = objKeys[i];
+        const value = stableJSONStringify(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += stringify(key) + ':' + value;
+    }
+    return '{' + out + '}';
+}
+/**
+ * Converts an arbitrary value to an Error.
+ *
+ * @param x anything
+ * @returns Error corresponding to x
+ */
+function toError(x) {
+    if (x instanceof Error) {
+        return x;
+    }
+    return new Error(typeof x === 'string' ? x : JSON.stringify(x));
+}
+/**
+ * Deep copies a JSON object. Only works for non-complex values.
+ * No Date or Functions etc.
+ */
+function deepCopy(x) {
+    const stringified = stringify(x);
+    return stringified ? parse(stringified) : undefined;
+}
+
+var HttpStatusCode$1;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+})(HttpStatusCode$1 || (HttpStatusCode$1 = {}));
+
+/**
+ * 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.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that makes network requests but does not try to
+ * use the store.
+ */
+class NetworkCommand extends BaseCommand {
+    constructor(services) {
+        super();
+        this.services = services;
+        this.subscriptions = [];
+        this.exposeSubscribeAndRefresh = false;
+    }
+    execute() {
+        const result = this.fetch();
+        if (this.exposeSubscribeAndRefresh) {
+            return this.fetchSubscribableResult(result);
+        }
+        return result;
+    }
+    fetchSubscribableResult(res) {
+        return res.then((networkResult) => {
+            if (networkResult.isErr()) {
+                return err(networkResult.error);
+            }
+            else {
+                const data = networkResult.value;
+                return ok({
+                    data,
+                    subscribe: (cb) => {
+                        this.subscriptions.push(cb);
+                        return () => {
+                            this.subscriptions = this.subscriptions.filter((cb2) => cb2 !== cb);
+                        };
+                    },
+                    refresh: () => this.refresh(),
+                });
+            }
+        });
+    }
+    refresh() {
+        return this.execute().then((newResult) => {
+            if (newResult.isOk()) {
+                if (isSubscribableResult(newResult)) {
+                    const value = newResult.value;
+                    this.subscriptions.forEach((cb) => {
+                        cb(ok(value.data));
+                    });
+                }
+                return ok(undefined);
+            }
+            return err(newResult.error);
+        });
+    }
+    async afterRequestHooks(_options) { }
+}
+function buildServiceDescriptor$e() {
+    return {
+        type: 'networkCommandBaseClass',
+        version: '1.0',
+        service: NetworkCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of NetworkCommand that uses Aura as the transport mechanism
+ */
+class AuraNetworkCommand extends NetworkCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+        this.actionConfig = {
+            background: false,
+            hotspot: true,
+            longRunning: false,
+            storable: false,
+        };
+    }
+    coerceAuraErrors(auraErrors) {
+        return toError(auraErrors[0]); // Default Implmentation stringifies the response
+    }
+    convertAuraResponseToData(responsePromise, coerceError) {
+        return responsePromise
+            .then((response) => {
+            const auraReturnValue = response.getReturnValue();
+            try {
+                this.afterRequestHooks({ statusCode: 200 }); // Treat all aura success as 200
+            }
+            catch (e) { }
+            return ok(auraReturnValue);
+        })
+            .catch((error) => {
+            if (!error || !error.getError) {
+                return err(toError('Failed to get error from response'));
+            }
+            else {
+                const actionErrors = error.getError();
+                if (actionErrors.length > 0) {
+                    return err(coerceError(actionErrors));
+                }
+                else {
+                    return err(toError('Error fetching component'));
+                }
+            }
+        });
+    }
+    fetch() {
+        return this.convertAuraResponseToData(this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig), this.coerceAuraErrors);
+    }
+}
+
+function buildServiceDescriptor$d() {
+    return {
+        type: 'auraNetworkCommandBaseClass',
+        version: '1.0',
+        service: AuraNetworkCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+// Needs TS 2023+ (esnext) AND node 20+ to remove
+function setOverlaps(setA, setB) {
+    if (setA.size > setB.size) {
+        for (const key of setB.keys()) {
+            if (setA.has(key)) {
+                return true;
+            }
+        }
+    }
+    else {
+        for (const key of setA) {
+            if (setB.has(key)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class CacheControlCommand extends BaseCommand {
+    constructor(services) {
+        super();
+        this.services = services;
+        this.keysUsed = new Set();
+        this.keysUpdated = undefined;
+        this.operationType = 'query';
+        this.lastEmittedData = undefined;
+        this.unsubscribeFromKeysImpl = () => undefined;
+        this.subscriptions = [];
+        this.instantiationTime = Date.now() / 1000; // in seconds
+    }
+    execute(overrides) {
+        this.keysUpdated = undefined;
+        this.unsubscribeFromKeys();
+        const mergedCacheControlConfig = mergeCacheControlConfigs(this.cacheControlStrategyConfig, overrides);
+        let returnData;
+        let returnError;
+        const requestRunner = {
+            readFromCache: (cache) => {
+                const resultPromise = this.buildResultWithSubscribe(cache);
+                return resultPromise.then((result) => {
+                    if (result.isErr()) {
+                        return err(result.error);
+                    }
+                    returnData = result;
+                    return ok(undefined);
+                });
+            },
+            requestFromNetwork: () => {
+                const that = this;
+                return (async function* () {
+                    const result = await that.requestFromNetwork();
+                    if (result.isErr()) {
+                        returnError = result;
+                    }
+                    yield result;
+                })();
+            },
+            writeToCache: (cache, networkResult) => {
+                return this.writeToCacheAndRecordKeys(cache, networkResult);
+            },
+        };
+        const resultPromise = this.services.cacheController.execute(mergedCacheControlConfig, requestRunner, {
+            instrumentationAttributes: this.instrumentationAttributes,
+        });
+        return resultPromise.then((result) => {
+            return this.publishUpdatedKeys().then(() => {
+                // First check if there was an error from the network
+                if (returnError) {
+                    return returnError;
+                }
+                // Then return other errors from read/write
+                if (result.isErr()) {
+                    return err(result.error);
+                }
+                if (this.subscriptions.length > 0) {
+                    this.subscribeToKeysUsed();
+                }
+                if (returnData === undefined) {
+                    return err(new Error('Cache miss after fetching from network'));
+                }
+                if (returnData.isOk() && this.lastEmittedData === undefined) {
+                    this.lastEmittedData = returnData.value.data;
+                }
+                return returnData;
+            });
+        });
+    }
+    publishUpdatedKeys() {
+        if (this.services.pubSub) {
+            if (this.keysUpdated !== undefined && this.keysUpdated.size > 0) {
+                return this.services.pubSub.publish({
+                    type: 'cacheUpdate',
+                    data: this.keysUpdated,
+                });
+            }
+        }
+        return resolvedPromiseLike(undefined);
+    }
+    subscribeToKeysUsed() {
+        this.unsubscribeFromKeys();
+        const { pubSub } = this.services;
+        if (!pubSub) {
+            this.unsubscribeFromKeysImpl = () => undefined;
+            return;
+        }
+        const rebuildUnsubscribe = pubSub.subscribe({
+            type: 'cacheUpdate',
+            predicate: (event) => setOverlaps(event.data, this.keysUsed),
+            callback: () => this.rerun({ now: this.instantiationTime }).then(() => undefined),
+            keys: this.keysUsed,
+        });
+        const refreshUnsubscribe = pubSub.subscribe({
+            type: 'cacheInvalidation',
+            predicate: (event) => setOverlaps(event.data, this.keysUsed),
+            callback: () => this.rerun().then(() => undefined),
+            keys: this.keysUsed,
+        });
+        this.unsubscribeFromKeysImpl = () => {
+            rebuildUnsubscribe();
+            refreshUnsubscribe();
+        };
+        return;
+    }
+    unsubscribeFromKeys() {
+        this.unsubscribeFromKeysImpl();
+    }
+    // TODO: This should likely be abstract in v2.  For v1, provide default comparison logic.
+    equals(result1, result2) {
+        return deepEquals(result1, result2);
+    }
+    async afterRequestHooks(_options) { }
+    refresh() {
+        return this.rerun({ cacheControlConfig: { type: 'no-cache' } }).then((result) => {
+            if (result.isErr()) {
+                return err(result.error);
+            }
+            return ok(undefined);
+        });
+    }
+    writeToCacheAndRecordKeys(cache, networkResult) {
+        const recordableCache = cache.record();
+        return this.writeToCache(recordableCache, networkResult).then((result) => {
+            this.instantiationTime = Date.now() / 1000;
+            this.keysUpdated = recordableCache.keysUpdated;
+            return ok(result);
+        });
+    }
+    buildResultWithSubscribe(cache) {
+        const recordableCache = cache.record();
+        const result = this.readFromCache(recordableCache);
+        return result.then((readResult) => {
+            if (readResult.isErr()) {
+                return err(readResult.error);
+            }
+            else {
+                const data = readResult.value;
+                this.keysUsed = recordableCache.keysRead;
+                return ok({
+                    data,
+                    subscribe: this.buildSubscribe(),
+                    refresh: () => this.refresh(),
+                });
+            }
+        });
+    }
+    /**
+     * Builds a function that subscribes to cache changes via the pubsub service. Whenever
+     * relevant cache updates occur, it re-reads the data and compares it against
+     * the last known value. If a change is detected, the provided
+     * callback is invoked.
+     *
+     * @param keysRead - keys of interest that were read during readFromCache
+     * @returns an unsubscribe function to stop watching for updates
+     */
+    buildSubscribe() {
+        return (consumerCallback) => {
+            if (this.subscriptions.length === 0 && this.operationType === 'query') {
+                this.subscribeToKeysUsed();
+            }
+            this.subscriptions.push(consumerCallback);
+            return () => {
+                this.subscriptions = this.subscriptions.filter((cb) => cb !== consumerCallback);
+                if (this.subscriptions.length === 0) {
+                    this.unsubscribeFromKeys();
+                }
+            };
+        };
+    }
+    rerun(overrides) {
+        return this.execute(overrides).then((result) => {
+            if (result.isErr()) {
+                this.invokeConsumerCallbacks(result);
+                return result;
+            }
+            if (!this.equals(this.lastEmittedData, result.value.data)) {
+                this.lastEmittedData = result.value.data;
+                this.invokeConsumerCallbacks(ok(result.value.data));
+            }
+            return result;
+        });
+    }
+    invokeConsumerCallbacks(data) {
+        this.subscriptions.forEach((cb) => {
+            try {
+                cb(data);
+            }
+            catch (error) {
+                // TODO: Add logging here
+            }
+        });
+    }
+}
+/**
+ * Merges two CacheControlStrategyConfig objects
+ *
+ */
+function mergeCacheControlConfigs(baseConfig, overrides) {
+    var _a;
+    if (!overrides) {
+        return baseConfig;
+    }
+    const now = (_a = overrides.now) !== null && _a !== void 0 ? _a : baseConfig.now;
+    if (!overrides.cacheControlConfig) {
+        return {
+            ...baseConfig,
+            now,
+        };
+    }
+    return {
+        ...overrides.cacheControlConfig,
+        now,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class AuraCacheControlCommand extends CacheControlCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+        this.actionConfig = {
+            background: false,
+            hotspot: true,
+            longRunning: false,
+            storable: false,
+        };
+    }
+    requestFromNetwork() {
+        return this.convertAuraResponseToData(this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig), (errs) => this.coerceError(errs));
+    }
+    coerceError(auraErrors) {
+        return toError(auraErrors[0]); // Default Implementation stringifies the response
+    }
+    convertAuraResponseToData(responsePromise, coerceError) {
+        return responsePromise
+            .then((response) => {
+            const auraReturnValue = response.getReturnValue();
+            try {
+                this.afterRequestHooks({ statusCode: 200 }); // Treat all aura success as 200
+            }
+            catch (e) { }
+            return ok(auraReturnValue);
+        })
+            .catch((error) => {
+            if (!error || !error.getError) {
+                return err(toError('Failed to get error from response'));
+            }
+            else {
+                const actionErrors = error.getError();
+                if (actionErrors.length > 0) {
+                    return err(coerceError(actionErrors));
+                }
+                else {
+                    return err(toError('Error fetching component'));
+                }
+            }
+        });
+    }
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class AuraResourceCacheControlCommand extends AuraCacheControlCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    execute() {
+        return super.execute();
+    }
+    readFromCache(cache) {
+        var _a;
+        const data = (_a = cache.get(this.buildKey())) === null || _a === void 0 ? void 0 : _a.value;
+        if (data === undefined) {
+            return resolvedPromiseLike(err(new Error('Failed to find data in cache')));
+        }
+        return resolvedPromiseLike(ok(data));
+    }
+    writeToCache(cache, networkResult) {
+        if (networkResult.isOk()) {
+            cache.set(this.buildKey(), {
+                value: networkResult.value,
+                metadata: {
+                    cacheControl: this.buildCacheControlMetadata(networkResult.value),
+                },
+            });
+        }
+        return resolvedPromiseLike(undefined);
+    }
+    buildKey() {
+        return `{"endpoint":${this.endpoint},"params":${stableJSONStringify(this.auraParams)}}`;
+    }
+}
+
+function buildServiceDescriptor$c() {
+    return {
+        type: 'auraResourceCacheControlCommand',
+        version: '1.0',
+        service: AuraResourceCacheControlCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    readFromCache(cache) {
+        const data = this.buildResultType().query(cache, this.buildQuery());
+        if (data.isErr()) {
+            return resolvedPromiseLike(err(new Error(`Failed to build data from type: ${stringify(data.error)}`)));
+        }
+        return resolvedPromiseLike(ok(data.value));
+    }
+    writeToCache(cache, networkResult) {
+        if (networkResult.isOk()) {
+            this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), this.buildWriteInput(networkResult.value));
+        }
+        return resolvedPromiseLike(undefined);
+    }
+}
+
+function buildServiceDescriptor$b() {
+    return {
+        type: 'auraNormalizedCacheControlCommand',
+        version: '1.0',
+        service: AuraNormalizedCacheControlCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class HttpCacheControlCommand extends CacheControlCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    requestFromNetwork() {
+        return this.fetch();
+    }
+    fetch() {
+        return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    async coerceError(errorResponse) {
+        return toError(errorResponse.statusText); // Default Behavior
+    }
+    convertFetchResponseToData(response) {
+        return response.then((response) => {
+            if (response.ok) {
+                return response
+                    .json()
+                    .then((json) => ok(json), (reason) => err(toError(reason)))
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
+            }
+            else {
+                return this.coerceError(response)
+                    .then((coercedError) => {
+                    return err(coercedError);
+                })
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
+            }
+        }, (reason) => err(toError(reason)));
+    }
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that allows for extending abstract cache methods
+ *
+ * @typeParam Data cache result for read operations
+ * @typeParam NetworkResult cache result including network metadata
+ * @typeParam ExtraServices additional named services needed by a subclass
+ */
+class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    readFromCache(cache) {
+        const data = this.buildResultType().query(cache, this.buildQuery());
+        if (data.isErr()) {
+            return resolvedPromiseLike(err(new Error(`Failed to build data from type: ${stringify(data.error)}`)));
+        }
+        return resolvedPromiseLike(ok(data.value));
+    }
+    writeToCache(cache, networkResult) {
+        if (networkResult.isOk()) {
+            this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), this.buildWriteInput(networkResult.value));
+        }
+        return resolvedPromiseLike(undefined);
+    }
+}
+
+function buildServiceDescriptor$a() {
+    return {
+        type: 'httpNormalizedCacheControlCommand',
+        version: '1.0',
+        service: HttpNormalizedCacheControlCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of NetworkCommand that uses HTTP/fetch as the transport mechanism.
+ */
+class FetchNetworkCommand extends NetworkCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    fetch() {
+        return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    async coerceError(errorResponse) {
+        return toError(errorResponse.statusText); // Default Behavior
+    }
+    convertFetchResponseToData(response) {
+        return response.then((response) => {
+            if (response.ok) {
+                return response
+                    .json()
+                    .then((json) => ok(json), (reason) => err(toError(reason)))
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
+            }
+            else {
+                return this.coerceError(response)
+                    .then((coercedError) => {
+                    return err(coercedError);
+                })
+                    .finally(() => {
+                    try {
+                        this.afterRequestHooks({ statusCode: response.status });
+                    }
+                    catch (e) { }
+                });
+            }
+        }, (reason) => err(toError(reason)));
+    }
+}
+
+function buildServiceDescriptor$9() {
+    return {
+        type: 'fetchNetworkCommandBaseClass',
+        version: '1.0',
+        service: FetchNetworkCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that supports streaming responses and does not use the store.
+ */
+class StreamingCommand extends BaseCommand {
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    execute() {
+        return this.convertFetchStreamResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    convertFetchStreamResponseToData(response) {
+        return response.then((response) => {
+            if (response.ok && response.body) {
+                return ok(this.decodeByteStream(response.body));
+            }
+            else {
+                return err(toError(response.ok ? 'Response body not present' : response.statusText));
+            }
+        }, (reason) => err(toError(reason)));
+    }
+}
+
+function buildServiceDescriptor$8() {
+    return {
+        type: 'streamingCommandBaseClass',
+        version: '1.0',
+        service: StreamingCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of StreamingCommand that handles SSE (Server-Sent Event) streams.
+ */
+class SSECommand extends StreamingCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    /**
+     * Decodes the bytes returned by fetch into the correct shape.
+     *
+     * @param byteStream ReadableStream<Uint8Array> returned by fetch
+     * @returns ReadableStream<StreamedData> that will be the result of the Command
+     */
+    decodeByteStream(byteStream) {
+        return this.decodeSSEStream(byteStream
+            // eslint-disable-next-line no-undef
+            .pipeThrough(new TextDecoderStream())
+            .pipeThrough(new SSEParsingStream()));
+    }
+}
+const sseRegex = /^(?<field>[^:]*?)(: ?(?<value>.*?))?(?:\r\n?|\n)/;
+//                 +-------v------++--------v--------++-----v----+
+//                         |                |               |
+//                         |                |        CRLF | CR | LF
+//                         |                |
+//                         |    ": value", or ": comment" if no field name (optional)
+//                         |
+//               field name (optional); can be entire line if no ":"
+/**
+ * A TransformStream that parses server-sent event (SSE) data according to the SSE spec:
+ * https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+class SSEParsingStream extends TransformStream {
+    constructor() {
+        let ignoreLeadingLF = false, partialLine = '', data = '', event = '', id = '', retry;
+        super({
+            transform(chunk, controller) {
+                // account for case where chunk boundary splits \r\n
+                if (ignoreLeadingLF && chunk.startsWith('\n')) {
+                    // eslint-disable-next-line no-param-reassign
+                    chunk = chunk.slice(1);
+                }
+                ignoreLeadingLF = chunk.endsWith('\r');
+                // prepend partial last line from previous chunk
+                let text = partialLine + chunk;
+                let match;
+                while ((match = text.match(sseRegex))) {
+                    text = text.slice(match[0].length);
+                    // blank linke, end of text/event-stream message
+                    if (match.groups.field === '' && match.groups.value === undefined) {
+                        // drop messages with no data
+                        if (data === '') {
+                            event = '';
+                            continue;
+                        }
+                        // strip trailing \n from data
+                        if (data.endsWith('\n')) {
+                            data = data.slice(0, -1);
+                        }
+                        const sseMessage = {
+                            data,
+                            id,
+                            // default event value is "message"
+                            event: event || 'message',
+                        };
+                        if (retry !== undefined) {
+                            sseMessage.retry = retry;
+                        }
+                        controller.enqueue(sseMessage);
+                        // clear data & event for next message; id and retry persist until changed
+                        data = event = '';
+                    }
+                    // data: line
+                    else if (match.groups.field === 'data') {
+                        data += (match.groups.value || '') + '\n';
+                    }
+                    // event: line
+                    else if (match.groups.field === 'event') {
+                        event = match.groups.value || '';
+                    }
+                    // id: line
+                    else if (match.groups.field === 'id') {
+                        const idValue = match.groups.value || '';
+                        if (!idValue.includes('\u0000')) {
+                            id = idValue;
+                        }
+                    }
+                    // retry: line
+                    else if (match.groups.field === 'retry') {
+                        // ignore bogus values
+                        if (/^\d+$/.exec(match.groups.value)) {
+                            retry = parseInt(match.groups.value);
+                        }
+                    }
+                    // comment or unrecognized field, ignore
+                    else ;
+                }
+                // save partial line for next chunk
+                partialLine = text;
+            },
+        });
+    }
+}
+
+function buildServiceDescriptor$7() {
+    return {
+        type: 'SSECommandBaseClass',
+        version: '1.0',
+        service: SSECommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+function buildInstrumentCommand(services) {
+    const meter = services.instrumentation.metrics.getMeter('onestore');
+    return function instrumentCommand(commandClass, commandName) {
+        const invocationCounter = meter.createCounter(`${commandName}.command.invocation.count`);
+        const errorCounter = meter.createCounter(`${commandName}.command.error.count`);
+        const durationHistogram = meter.createHistogram(`${commandName}.command.duration`);
+        return class extends commandClass {
+            execute(...args) {
+                invocationCounter.add(1);
+                let result;
+                const start = services.instrumentation.currentTimeMs();
+                function recordDuration() {
+                    const end = services.instrumentation.currentTimeMs();
+                    durationHistogram.record(end - start);
+                }
+                try {
+                    result = super.execute(...args);
+                }
+                catch (e) {
+                    errorCounter.add(1);
+                    throw e;
+                }
+                if (typeof result === 'object' && result !== null && 'then' in result) {
+                    result.then(recordDuration, () => {
+                        errorCounter.add(1);
+                    });
+                }
+                else {
+                    recordDuration();
+                }
+                return result;
+            }
+        };
+    };
+}
+
+function buildServiceDescriptor$6(instrumentation) {
+    return {
+        type: 'instrumentCommand',
+        version: '1.0',
+        service: buildInstrumentCommand({ instrumentation }),
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/* eslint-disable no-dupe-class-members */
+class O11yOTelTraceAPI {
+    constructor(services) {
+        this.services = services;
+    }
+    getTracer(name, _version, _options) {
+        const o11yInstrumentation = getInstrumentation(name);
+        return new O11yTracer(o11yInstrumentation, this.services.logger);
+    }
+}
+class O11yTracer {
+    constructor(o11yInstrumentation, logger) {
+        this.o11yInstrumentation = o11yInstrumentation;
+        this.logger = logger;
+    }
+    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);
+    }
+    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);
+        return fun(span);
+    }
+}
+class O11ySpan {
+    constructor(activity, logger) {
+        this.activity = activity;
+        this.logger = logger;
+        this._isRecording = true;
+        this.attributes = {};
+    }
+    spanContext() {
+        return {
+            traceId: this.activity.getRootId(),
+            spanId: this.activity.getId(),
+            traceFlags: this.activity.getIsSampled() ? 1 : 0,
+        };
+    }
+    setAttribute(key, value) {
+        this.attributes[key] = value;
+        return this;
+    }
+    setAttributes(attributes) {
+        this.attributes = { ...this.attributes, ...attributes };
+        return this;
+    }
+    addEvent(_name, _attributesOrStartTime, _startTime) {
+        this.logger.warn('O11ySpan does not support addEvents.');
+        return this;
+    }
+    setStatus(_status) {
+        this.logger.warn('O11ySpan does not support setStatus.');
+        return this;
+    }
+    updateName(_name) {
+        this.logger.warn('O11ySpan does not support updateName.');
+        return this;
+    }
+    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;
+    }
+    isRecording() {
+        return this._isRecording;
+    }
+    recordException(exception, _time) {
+        // TODO: Add support for exception schemas and data
+        this.activity.error(exception);
+    }
+}
+
+class O11yOTelMetricsAPI {
+    constructor(services) {
+        this.services = services;
+    }
+    getMeter(name, 
+    // TODO: Not sure what to do with these?
+    _version, __options) {
+        const o11yInstrumentation = getInstrumentation(name);
+        return new O11yMeter(o11yInstrumentation, this.services.logger);
+    }
+}
+class O11yMeter {
+    constructor(o11yInstrumentation, logger) {
+        this.o11yInstrumentation = o11yInstrumentation;
+        this.logger = logger;
+    }
+    createHistogram(name, _options) {
+        return new O11yHistogram(name, this.o11yInstrumentation, this.logger);
+    }
+    createCounter(name, options) {
+        if (options) {
+            this.logger.warn('counter options not supported in O11y instrumentation');
+        }
+        return new O11yCounter(name, this.o11yInstrumentation, this.logger);
+    }
+    createUpDownCounter(_name, _options) {
+        return new O11yUpDownCounter(this.logger);
+    }
+    createObservableGauge(_name, _options) {
+        return new O11yObservableGuage(this.logger);
+    }
+    createObservableCounter(_name, _options) {
+        return new O11yObservableCounter(this.logger);
+    }
+    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');
+    }
+}
+class O11yCounter {
+    constructor(name, o11yInstrumentation, logger) {
+        this.name = name;
+        this.o11yInstrumentation = o11yInstrumentation;
+        this.logger = logger;
+    }
+    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, undefined, sanitizeAttributes(attributes));
+    }
+}
+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;
+        }
+        this.o11yInstrumentation.trackValue(this.name, value, undefined, sanitizeAttributes(attributes));
+    }
+}
+class O11yUpDownCounter {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    add(_value, _attributes, _context) {
+        this.logger.warn('O11yUpDownCounter not supported yet.');
+    }
+}
+class O11yObservableCounter {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    addCallback(_callback) {
+        this.logger.warn('O11yObservableCounter not supported yet. Defaulting to noop.');
+    }
+    removeCallback(_callback) {
+        this.logger.warn('O11yObservableCounter not supported yet. Defaulting to noop.');
+    }
+}
+class O11yObservableGuage {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    addCallback(_callback) {
+        this.logger.warn('O11yObservableGuage not supported yet. Defaulting to noop.');
+    }
+    removeCallback(_callback) {
+        this.logger.warn('O11yObservableGuage not supported yet. Defaulting to noop.');
+    }
+}
+class O11yObservableUpDownCounter {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    addCallback(_callback) {
+        this.logger.warn('O11yObservableUpDownCounter not supported yet. Defaulting to noop.');
+    }
+    removeCallback(_callback) {
+        this.logger.warn('O11yObservableUpDownCounter not supported yet. Defaulting to noop.');
+    }
+}
+function sanitizeAttributes(attributes) {
+    if (!attributes)
+        return;
+    const metricTags = {};
+    Object.entries(attributes).forEach(([key, value]) => {
+        if (value !== undefined && !Array.isArray(value)) {
+            metricTags[key] = value;
+        }
+    });
+    return metricTags;
+}
+
+class O11yInstrumentation {
+    constructor(services) {
+        this.services = services;
+        this.currentTimeMs = () => performance.now();
+        this.trace = new O11yOTelTraceAPI(this.services);
+        this.metrics = new O11yOTelMetricsAPI(this.services);
+    }
+}
+function buildServiceDescriptor$5(logger) {
+    return {
+        type: 'instrumentation',
+        version: '1.0',
+        service: new O11yInstrumentation({ logger }),
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/* eslint-disable no-dupe-class-members */
+/**
+ A utility class for recording actions made on a cache.
+ */
+class DefaultRecordableCache {
+    constructor(baseCache) {
+        this.baseCache = baseCache;
+        this.keysRead = new Set();
+        this.missingKeysRead = new Set();
+        this.keysUpdated = new Set();
+        this.metadataKeysUpdated = new Set();
+    }
+    delete(key) {
+        this.keysUpdated.add(key);
+        this.baseCache.delete(key);
+    }
+    get(key, options) {
+        this.keysRead.add(key);
+        const value = this.baseCache.get(key);
+        if (value === undefined) {
+            this.missingKeysRead.add(key);
+        }
+        if (options === null || options === void 0 ? void 0 : options.copy) {
+            return deepCopy(value);
+        }
+        return value;
+    }
+    set(key, value) {
+        this.keysUpdated.add(key);
+        this.metadataKeysUpdated.add(key);
+        this.baseCache.set(key, value);
+    }
+    setMetadata(key, cacheControlMetadata) {
+        this.metadataKeysUpdated.add(key);
+        this.baseCache.setMetadata(key, cacheControlMetadata);
+    }
+    length() {
+        return this.baseCache.length();
+    }
+    keys() {
+        return this.baseCache.keys();
+    }
+    entries() {
+        return this.baseCache.entries();
+    }
+    record() {
+        return new DefaultRecordableCache(this);
+    }
+    filter(predicate) {
+        return new DefaultFilteredCache(this, predicate);
+    }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
+}
+/**
+ A utility class for filtering cache entries based on a given predicate.
+ */
+class DefaultFilteredCache {
+    constructor(baseCache, predicate) {
+        this.baseCache = baseCache;
+        this.predicate = predicate;
+    }
+    delete(key) {
+        this.baseCache.delete(key);
+    }
+    get(key, options) {
+        const result = this.baseCache.get(key);
+        // if we're chaining filtered caches together, then it's possible the result will be undefined here
+        if (result && this.predicate(key, result)) {
+            if (options === null || options === void 0 ? void 0 : options.copy) {
+                return deepCopy(result);
+            }
+            return result;
+        }
+        return undefined;
+    }
+    set(key, value) {
+        this.baseCache.set(key, value);
+    }
+    setMetadata(key, cacheControlMetadata) {
+        this.baseCache.setMetadata(key, cacheControlMetadata);
+    }
+    length() {
+        return this.getFilteredKeys().size;
+    }
+    keys() {
+        return this.getFilteredKeys();
+    }
+    entries() {
+        return this.getFilteredEntries();
+    }
+    record() {
+        return new DefaultRecordableCache(this);
+    }
+    filter(predicate) {
+        return new DefaultFilteredCache(this, predicate);
+    }
+    getFilteredEntries() {
+        return this.baseCache.entries().filter(([key, _value]) => {
+            return this.get(key);
+        });
+    }
+    getFilteredKeys() {
+        const filteredKeySet = new Set();
+        this.baseCache.keys().forEach((key) => {
+            if (this.get(key)) {
+                filteredKeySet.add(key);
+            }
+        });
+        return filteredKeySet;
+    }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
+}
+/**
+ A utility class for automatically setting the generated time on all write operations
+ */
+class FixedTimeWritableCache {
+    constructor(baseCache, generatedTime) {
+        this.baseCache = baseCache;
+        this.generatedTime = generatedTime;
+    }
+    delete(key) {
+        this.baseCache.delete(key);
+    }
+    get(key, options) {
+        return this.baseCache.get(key, options);
+    }
+    set(key, value) {
+        this.baseCache.set(key, {
+            ...value,
+            metadata: {
+                ...value.metadata,
+                cacheControl: { ...value.metadata.cacheControl, generatedTime: this.generatedTime },
+            },
+        });
+    }
+    setMetadata(key, cacheControlMetadata) {
+        this.baseCache.setMetadata(key, {
+            ...cacheControlMetadata,
+            generatedTime: this.generatedTime,
+        });
+    }
+    length() {
+        return this.baseCache.length();
+    }
+    keys() {
+        return this.baseCache.keys();
+    }
+    entries() {
+        return this.baseCache.entries();
+    }
+    record() {
+        return new DefaultRecordableCache(this);
+    }
+    filter(predicate) {
+        return new DefaultFilteredCache(this, predicate);
+    }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
+}
+
+/* eslint-disable no-dupe-class-members */
+class DefaultCache {
+    constructor() {
+        this.data = {};
+    }
+    get(key, options) {
+        if (options === null || options === void 0 ? void 0 : options.copy) {
+            return deepCopy(this.data[key]);
+        }
+        return this.data[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.metadata.cacheControl.type === 'no-store') {
+            return;
+        }
+        this.data[key] = {
+            ...entry,
+            metadata: {
+                ...entry.metadata,
+                type: entry.metadata.type || {
+                    namespace: 'OneStore:Internal',
+                    name: 'UnknownType',
+                },
+                cacheControl: {
+                    generatedTime: Date.now() / 1000,
+                    ...entry.metadata.cacheControl,
+                },
+            },
+        };
+    }
+    /**
+     * Removes the cache entry associated with the specified key.
+     *
+     * @param key key to be removed from the store
+     */
+    delete(key) {
+        delete this.data[key];
+    }
+    /**
+     * Sets the metadata for the specified key if the key is in cache.
+     * If the key doesn't exist, it does nothing.
+     *
+     * @param key key at which to store metadata
+     * @param cacheControlMetadata metadata to be stored
+     */
+    setMetadata(key, cacheControlMetadata) {
+        if (key in this.data) {
+            this.data[key].metadata.cacheControl = {
+                generatedTime: Date.now() / 1000,
+                ...cacheControlMetadata,
+            };
+        }
+    }
+    length() {
+        return this.keys().size;
+    }
+    keys() {
+        return new Set(Object.keys(this.data));
+    }
+    entries() {
+        return Object.entries(this.data);
+    }
+    record() {
+        return new DefaultRecordableCache(this);
+    }
+    filter(predicate) {
+        return new DefaultFilteredCache(this, predicate);
+    }
+    buildFixedTimeWritableCache(generatedTime) {
+        return new FixedTimeWritableCache(this, generatedTime);
+    }
+}
+
+function buildServiceDescriptor$4() {
+    return {
+        type: 'cache',
+        version: '1.0',
+        service: new DefaultCache(),
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+class CacheControlStrategy {
+    constructor(services, config, requestRunner) {
+        this.services = services;
+        this.config = config;
+        this.requestRunner = requestRunner;
+        this.filteredCache = this.services.cache.filter((_, entry) => {
+            const { cacheControl } = entry.metadata;
+            return !this.expiredChecks.some((check) => check(cacheControl));
+        });
+    }
+    get expiredChecks() {
+        return [
+            (cacheControlMetadata) => cacheControlMetadata.type === 'max-age' &&
+                this.config.now > cacheControlMetadata.generatedTime + cacheControlMetadata.maxAge,
+            (cacheControlMetadata) => cacheControlMetadata.type === 'max-age' && cacheControlMetadata.maxAge <= 0,
+            (cacheControlMetadata) => cacheControlMetadata.type === 'no-store',
+            (cacheControlMetadata) => cacheControlMetadata.type === 'no-cache' &&
+                cacheControlMetadata.generatedTime < this.config.now,
+        ];
+    }
+}
+
+class NoCacheCacheControlStrategy extends CacheControlStrategy {
+    execute() {
+        // TODO - should be using wrapper here that suppresses no-store writes
+        const tempCache = this.filteredCache;
+        return new Promise(async (resolve, reject) => {
+            try {
+                let readResult = ok(undefined);
+                for await (const rfnResult of this.requestRunner.requestFromNetwork()) {
+                    if (rfnResult) {
+                        const result = await this.services.cacheInclusionPolicy.write({
+                            l1: tempCache,
+                            writeToL1: (l1) => this.requestRunner.writeToCache(l1, rfnResult),
+                        });
+                        if (result.isErr()) {
+                            return resolve(result);
+                        }
+                    }
+                    // give readFromCache another shot at the cache
+                    readResult = await this.services.cacheInclusionPolicy.read({
+                        l1: tempCache,
+                        readFromL1: (l1) => this.requestRunner.readFromCache(l1),
+                    });
+                    if (readResult.isOk()) {
+                        resolve(readResult);
+                    }
+                }
+                return resolve(readResult);
+            }
+            catch (error) {
+                return reject(error);
+            }
+        });
+    }
+}
+
+class MaxAgeCacheControlStrategy extends CacheControlStrategy {
+    execute(options) {
+        const startTime = this.services.instrumentation
+            ? this.services.instrumentation.currentTimeMs()
+            : 0;
+        return this.services.cacheInclusionPolicy
+            .read({
+            l1: this.filteredCache,
+            readFromL1: (l1) => this.requestRunner.readFromCache(l1),
+        })
+            .then((value) => {
+            // ignore error from initial cache read
+            if (value.isOk()) {
+                this.collectCacheHitInstrumentation(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
+                return ok(undefined);
+            }
+            this.collectCacheMissInstrumentation(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
+            // initial cache read failed, awaits are ok beyond this point since the data
+            // must come from network requests
+            const tempCache = this.filteredCache;
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let readResult = ok(undefined);
+                    for await (const rfnResult of this.requestRunner.requestFromNetwork()) {
+                        // async generator has a value to ingest
+                        if (rfnResult) {
+                            const result = await this.services.cacheInclusionPolicy.write({
+                                l1: tempCache,
+                                writeToL1: (l1) => this.requestRunner.writeToCache(l1, rfnResult),
+                            });
+                            if (result.isErr()) {
+                                return resolve(err(result.error));
+                            }
+                        }
+                        // give readFromCache another shot at the cache
+                        readResult = await this.services.cacheInclusionPolicy.read({
+                            l1: tempCache,
+                            readFromL1: (l1) => this.requestRunner.readFromCache(l1),
+                        });
+                        if (readResult.isOk()) {
+                            resolve(ok(undefined));
+                        }
+                    }
+                    return resolve(readResult);
+                }
+                catch (e) {
+                    return reject(e);
+                }
+            });
+        });
+    }
+    collectCacheHitInstrumentation(startTime, instrumentationAttributes) {
+        if (this.services.instrumentation) {
+            const meter = this.services.instrumentation.metrics.getMeter('onestore');
+            meter
+                .createCounter(`command.max-age.cache-hit.count`)
+                .add(1, instrumentationAttributes);
+            meter
+                .createHistogram(`command.max-age.cache-hit.duration`)
+                .record(this.services.instrumentation.currentTimeMs() - startTime, instrumentationAttributes);
+        }
+    }
+    collectCacheMissInstrumentation(startTime, instrumentationAttributes) {
+        if (this.services.instrumentation) {
+            const meter = this.services.instrumentation.metrics.getMeter('onestore');
+            meter
+                .createCounter(`command.max-age.cache-miss.count`)
+                .add(1, instrumentationAttributes);
+            meter
+                .createHistogram(`command.max-age.cache-miss.duration`)
+                .record(this.services.instrumentation.currentTimeMs() - startTime, instrumentationAttributes);
+        }
+    }
+    get expiredChecks() {
+        const config = this.config;
+        return [
+            ...super.expiredChecks,
+            (cacheControlMetadata) => {
+                return cacheControlMetadata.generatedTime + config.requestMaxAge < config.now;
+            },
+        ];
+    }
+}
+
+/**
+ * A class that allows the execution of requested cache control strategies,
+ * while also enforcing the canonical cache control metadata.
+ */
+class CacheController {
+    constructor(services) {
+        this.services = services;
+    }
+    execute(config, requestRunner, options) {
+        const strategy = this.getCacheControlStrategy(config, requestRunner);
+        return strategy.execute(options);
+    }
+    getCacheControlStrategy(config, requestRunner) {
+        if (config.type === 'max-age') {
+            return new MaxAgeCacheControlStrategy(this.services, config, requestRunner);
+        }
+        else if (config.type === 'no-cache') {
+            return new NoCacheCacheControlStrategy(this.services, config, requestRunner);
+        }
+        throw new Error(`Unknown cache control strategy ${config.type}`);
+    }
+    /**
+     * Finds cache entries that match the given query.
+     * Returns an async generator that yields `[key, entry]`.
+     */
+    async *find(query) {
+        yield* this.services.cacheInclusionPolicy.find(query);
+    }
+    /**
+     * Finds and modifies cache entries that match the given query.
+     * Extends `find(query)` and returns an async generator of modified keys.
+     */
+    async *findAndModify(query, cacheUpdate) {
+        yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
+    }
+}
+
+function buildServiceDescriptor$3(cache, cacheInclusionPolicy) {
+    return {
+        type: 'cacheController',
+        version: '1.0',
+        service: new CacheController({ cache, cacheInclusionPolicy }),
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+const EventTypeWildcard = Symbol('EventTypeWildcard');
+
+/**
+ * A simple implementation of PubSubService.
+ */
+class DefaultPubSubService {
+    constructor() {
+        this.subscriptions = new Map();
+    }
+    subscribe(subscription) {
+        let eventTypeSubscriptions = this.subscriptions.get(subscription.type);
+        if (eventTypeSubscriptions === undefined) {
+            eventTypeSubscriptions = [];
+            this.subscriptions.set(subscription.type, eventTypeSubscriptions);
+        }
+        eventTypeSubscriptions.push(subscription);
+        return () => {
+            this.subscriptions.set(subscription.type, this.subscriptions.get(subscription.type).filter((value) => value !== subscription));
+        };
+    }
+    publish(event) {
+        const promises = [];
+        const subscriptions = this.getSubscriptions(event);
+        subscriptions.forEach((subscription) => {
+            // need to check that the subscription hasn't been unsubscribed during one of the callbacks
+            if (!this.getSubscriptions(event).includes(subscription)) {
+                return;
+            }
+            // Ensure callback maintains its context
+            const returnVal = subscription.callback.call(subscription, event);
+            if (isPromiseLike(returnVal)) {
+                promises.push(returnVal);
+            }
+        });
+        if (promises.length > 0) {
+            return Promise.all(promises).then(() => undefined);
+        }
+        return resolvedPromiseLike(undefined);
+    }
+    getSubscriptions(event) {
+        const eventTypeSubscriptions = this.subscriptions.get(event.type);
+        const wildcardSubscriptions = this.subscriptions.get(EventTypeWildcard);
+        if (eventTypeSubscriptions === undefined && wildcardSubscriptions === undefined) {
+            return [];
+        }
+        let matchingSubscriptions = [];
+        if (eventTypeSubscriptions !== undefined) {
+            matchingSubscriptions = eventTypeSubscriptions.filter((subscription) => {
+                if (subscription.predicate) {
+                    return subscription.predicate(event);
+                }
+                return true;
+            });
+        }
+        matchingSubscriptions = [...matchingSubscriptions, ...(wildcardSubscriptions || [])];
+        return matchingSubscriptions;
+    }
+}
+/**
+ * Constructs a default PubSubService
+ *
+ * @returns default PubSubServiceDescriptor
+ */
+function buildServiceDescriptor$2() {
+    return {
+        type: 'pubSub',
+        version: '1.0',
+        service: new DefaultPubSubService(),
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * CacheInclusionPolicy is an interface for accessing the cache
+ * and synchronizing the cache data with another external cache.
+ *
+ * https://en.wikipedia.org/wiki/Cache_inclusion_policy
+ */
+class CacheInclusionPolicyService {
+}
+
+const isAndQuery = (query) => '$and' in query;
+const isOrQuery = (query) => '$or' in query;
+const isNotQuery = (query) => '$not' in query;
+const matchesMetadata = (metadataQuery, cacheControl) => {
+    var _a;
+    if ('cacheControlType' in metadataQuery &&
+        cacheControl.type !== metadataQuery.cacheControlType.$eq) {
+        return false;
+    }
+    if ('maxAge' in metadataQuery && cacheControl.type === 'max-age') {
+        const maxAge = (_a = cacheControl.maxAge) !== null && _a !== void 0 ? _a : 0;
+        if ((metadataQuery.maxAge.$gte !== undefined && maxAge < metadataQuery.maxAge.$gte) ||
+            (metadataQuery.maxAge.$lte !== undefined && maxAge > metadataQuery.maxAge.$lte)) {
+            return false;
+        }
+    }
+    return true;
+};
+function queryToPredicate(query) {
+    return (key, entry) => {
+        if (!query)
+            return false;
+        if (isAndQuery(query))
+            return query.$and.every((subQuery) => queryToPredicate(subQuery)(key, entry));
+        if (isOrQuery(query))
+            return query.$or.some((subQuery) => queryToPredicate(subQuery)(key, entry));
+        if (isNotQuery(query))
+            return !queryToPredicate(query.$not)(key, entry);
+        if ('key' in query)
+            return matchesKey(query.key, key);
+        if ('metadata' in query)
+            return matchesMetadata(query.metadata, entry.metadata.cacheControl);
+        if ('value' in query)
+            return false; // TODO: Not implemented
+        throw new Error('Unknown Query Operation');
+    };
+}
+function matchesKey(keyQuery, key) {
+    if ('$regex' in keyQuery) {
+        return keyQuery.$regex.test(key);
+    }
+    return false;
+}
+
+/**
+ * Processes a cache update operation and determines the appropriate modification.
+ *
+ * This function analyzes the provided `update` and the `existing` cache entry
+ * to determine the necessary update type. It returns one of three possible outcomes:
+ *
+ * - `{ type: 'entry', entry }`: A full cache entry update, including both value and metadata.
+ * - `{ type: 'metadata', metadata }`: A metadata-only update, leaving the value unchanged.
+ * - `{ type: 'no-op' }`: No changes are needed, and the cache should remain as is.
+ *
+ * @param update - The cache update operation to apply.
+ * @param existing - The existing cache entry being modified.
+ * @returns An object indicating the type of update:
+ *   - A full cache entry update (`type: 'entry'`)
+ *   - A metadata-only update (`type: 'metadata'`)
+ *   - A no-op (`type: 'no-op'`) if no changes are required.
+ */
+function buildUpdate(update, existing) {
+    switch (update.type) {
+        case 'invalidate':
+            const updatedCacheControl = buildInvalidatedCacheControl(existing.metadata.cacheControl);
+            return updatedCacheControl !== undefined
+                ? { type: 'metadata', metadata: updatedCacheControl }
+                : { type: 'no-op' };
+        default:
+            throw new Error(`Invalid update operation: ${update.type}`);
+    }
+}
+/**
+ * Builds an updated CacheControlMetadata object that invalidates the cache entry.
+ *
+ * @param existingCacheControl - The current CacheControlMetadata.
+ * @returns A new CacheControlMetadata object with `maxAge` set to `0`, or undefined if no changes are needed.
+ */
+function buildInvalidatedCacheControl(existingCacheControl) {
+    switch (existingCacheControl.type) {
+        case 'max-age':
+        case 'stale-while-revalidate':
+            if (existingCacheControl.maxAge !== 0) {
+                return {
+                    ...existingCacheControl,
+                    maxAge: 0,
+                };
+            }
+    }
+    return undefined; // No-op: no changes
+}
+
+/**
+ * Implementation of CacheInclusionPolicy that uses a single level, in memory,
+ * synchronous L1 cache.
+ */
+class InMemoryCacheInclusionPolicy extends CacheInclusionPolicyService {
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    /**
+     * Reads data out of a single level in memory store.
+     */
+    read(options) {
+        const { l1, readFromL1 } = options;
+        // l1 is all we've got
+        return readFromL1(l1);
+    }
+    /**
+     * Writes data to a single level in memory store.
+     */
+    write(options) {
+        const { l1, writeToL1 } = options;
+        return writeToL1(l1);
+    }
+    /**
+     * Finds cache entries that match the given query.
+     * Returns an async generator that yields `[key, entry]`.
+     */
+    async *find(query) {
+        const cache = this.services.cache;
+        const predicate = queryToPredicate(query);
+        const filteredEntries = cache.filter(predicate).entries();
+        for (const entry of filteredEntries) {
+            yield entry;
+        }
+    }
+    /**
+     * Finds and modifies cache entries that match the given query.
+     * Extends `find(query)` and returns an async generator of modified keys.
+     */
+    async *findAndModify(query, cacheUpdate) {
+        const cache = this.services.cache;
+        for await (const [key, value] of this.find(query)) {
+            const update = buildUpdate(cacheUpdate, value);
+            switch (update.type) {
+                case 'entry':
+                    this.write({
+                        l1: cache,
+                        writeToL1: (l1) => resolvedPromiseLike(ok(l1.set(key, update.entry))),
+                    });
+                    yield key;
+                    break;
+                case 'metadata':
+                    this.write({
+                        l1: cache,
+                        writeToL1: (l1) => resolvedPromiseLike(ok(l1.setMetadata(key, update.metadata))),
+                    });
+                    yield key;
+                    break;
+            }
+        }
+    }
+}
+/**
+ * Constructs an in-memory-only CacheInclusionPolicy.
+ *
+ * @returns in-memory-only CacheInclusionPolicy
+ */
+function buildInMemoryCacheInclusionPolicyService(cache) {
+    return {
+        service: new InMemoryCacheInclusionPolicy({ cache }),
+        type: 'cacheInclusionPolicy',
+        version: '1.0',
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of StreamingCommand that handles NDJSON streams.
+ */
+class NDJSONCommand extends StreamingCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    /**
+     * Decodes the bytes returned by fetch into the correct shape.
+     *
+     * @param byteStream ReadableStream<Uint8Array> returned by fetch
+     * @returns ReadableStream<T> that will be the result of the Command
+     */
+    decodeByteStream(byteStream) {
+        return this.decodeNDJSONStream(byteStream
+            // eslint-disable-next-line no-undef
+            .pipeThrough(new TextDecoderStream())
+            .pipeThrough(new NDJSONParsingStream()));
+    }
+}
+/**
+ * A TransformStream that parses NDJSON data according to the NDJSON spec:
+ * https://github.com/ndjson/ndjson-spec
+ */
+class NDJSONParsingStream extends TransformStream {
+    constructor() {
+        let partialLine = '';
+        super({
+            transform(chunk, controller) {
+                const text = partialLine + chunk;
+                const lines = text.split(/\r?\n/);
+                partialLine = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed === '')
+                        continue;
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        controller.enqueue(parsed);
+                    }
+                    catch (e) {
+                        throw new Error(`Invalid NDJSON line: ${line}`);
+                    }
+                }
+            },
+            flush(controller) {
+                const trimmed = partialLine.trim();
+                if (trimmed !== '') {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        controller.enqueue(parsed);
+                    }
+                    catch (e) {
+                        throw new Error(`Invalid NDJSON final line: ${partialLine}`);
+                    }
+                }
+            },
+        });
+    }
+}
+
+function buildServiceDescriptor$1() {
+    return {
+        type: 'NDJSONCommandBaseClass',
+        version: '1.0',
+        service: NDJSONCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+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";
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+const LogLevelMap = {
+    TRACE: 4,
+    DEBUG: 3,
+    INFO: 2,
+    WARN: 1,
+    ERROR: 0,
+};
+/**
+ * A simple Logger implementation.
+ */
+class ConsoleLogger {
+    constructor(level = 'WARN', 
+    // eslint-disable-next-line no-console
+    printer = console.log, formatter = (level, message) => `${level}: ${message}`) {
+        this.level = level;
+        this.printer = printer;
+        this.formatter = formatter;
+        this.messages = [];
+    }
+    trace(message) {
+        this.log('TRACE', message);
+    }
+    debug(message) {
+        this.log('DEBUG', message);
+    }
+    info(message) {
+        this.log('INFO', message);
+    }
+    warn(message) {
+        this.log('WARN', message);
+    }
+    error(message) {
+        this.log('ERROR', message);
+    }
+    log(level, message) {
+        if (LogLevelMap[level] > LogLevelMap[this.level]) {
+            return;
+        }
+        this.printer(this.formatter(level, message));
+    }
+}
+/**
+ * Constructs a new LoggerService.
+ */
+function loggerService(level, printer, formatter) {
+    return new ConsoleLogger(level, printer, formatter);
+}
+
+var HttpStatusCode;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+})(HttpStatusCode || (HttpStatusCode = {}));
+
+/**
+ * Represents a JWT token with its decoded info and optional extra info.
+ *
+ * @typeparam T - Type of the additional payload in the JWT.
+ * @typeparam ExtraInfo - Type of the additional information.
+ */
+class JwtToken {
+    /**
+     * Create a new JwtToken.
+     *
+     * @param _token - The JWT string.
+     * @param _decodedInfo - The decoded information from the JWT.
+     * @param _extraInfo - Any additional information associated with the JWT.
+     */
+    constructor(_token, _decodedInfo, _extraInfo) {
+        this._token = _token;
+        this._decodedInfo = _decodedInfo;
+        this._extraInfo = _extraInfo;
+    }
+    /**
+     * Get the JWT string.
+     *
+     * @returns The JWT string.
+     */
+    get token() {
+        return this._token;
+    }
+    /**
+     * Get the additional information associated with the JWT.
+     *
+     * @returns The additional information.
+     */
+    get extraInfo() {
+        return this._extraInfo;
+    }
+    /**
+     * Get the decoded information from the JWT.
+     *
+     * @returns The decoded information.
+     */
+    get decodedInfo() {
+        return this._decodedInfo;
+    }
+    /**
+     * Get the remaining time in seconds until the JWT expires.
+     *
+     * @returns The remaining time in seconds.
+     */
+    get tokenRemainingSeconds() {
+        return this.decodedInfo.exp - Date.now() / 1000;
+    }
+    /**
+     * Check if the JWT is expired.
+     *
+     * @returns True if the JWT is expired, false otherwise.
+     */
+    get isExpired() {
+        return this.tokenRemainingSeconds <= 0;
+    }
+}
+
+/**
+ * Default logger if none is provided. Is overwritten in non-production environments.
+ */
+let defaultLogger = {
+    trace: () => { },
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+if (process.env.NODE_ENV !== 'production') {
+    defaultLogger = loggerService();
+}
+/**
+ * Decodes JWT token information and provides a default expiry if none is present.
+ *
+ * @param token - JWT token as a string.
+ * @param defaultTokenTTLInSeconds - Default expiry time in seconds if "exp" claim is not present in token.
+ * @param logger - Logger for logging warnings and errors.
+ *
+ * @returns An object of decoded JWT token information.
+ */
+function computeDecodedInfo(token, defaultTokenTTLInSeconds, logger) {
+    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;
+    }
+    return decodedInfo;
+}
+/**
+ * A repository for JWT tokens.
+ */
+class JwtRepository {
+    /**
+     * @param limitInSeconds - Time in seconds before the token's expiry to notify observers.
+     * @param defaultTokenTTLInSeconds - Default token expiry time in seconds if "exp" claim is not present in token.
+     * @param logger - Logger for logging warnings and errors.
+     */
+    constructor(limitInSeconds = 5, defaultTokenTTLInSeconds = 120, logger = defaultLogger) {
+        this.limitInSeconds = limitInSeconds;
+        this.defaultTokenTTLInSeconds = defaultTokenTTLInSeconds;
+        this.logger = logger;
+        this.observers = [];
+    }
+    /**
+     * Get the current token.
+     */
+    get token() {
+        return this._token;
+    }
+    /**
+     * Set the current token.
+     *
+     * @param token - JWT token as a string.
+     * @param extraInfo - Optional extra information.
+     */
+    setToken(token, extraInfo) {
+        const decodedInfo = computeDecodedInfo(token, this.defaultTokenTTLInSeconds, this.logger);
+        this._token = new JwtToken(token, decodedInfo, extraInfo);
+        this.observeTokenExpiration();
+        return this._token;
+    }
+    /**
+     * Remove the current token.
+     */
+    removeToken() {
+        this._token = undefined;
+        this.clearTimeoutHandler();
+    }
+    /**
+     * Subscribe to the token nearing its expiration.
+     *
+     * @param cb - Callback function to execute when token is nearing expiration.
+     */
+    subscribeToTokenNearExpiration(cb) {
+        this.observers.push(cb);
+        this.observeTokenExpiration();
+        return () => {
+            this.observers = this.observers.filter((observer) => observer !== cb);
+        };
+    }
+    /**
+     * Clear the timeout handler.
+     */
+    clearTimeoutHandler() {
+        if (this.timeoutHandler !== undefined) {
+            clearTimeout(this.timeoutHandler);
+        }
+    }
+    /**
+     * Observe and handle token expiration.
+     */
+    observeTokenExpiration() {
+        this.clearTimeoutHandler();
+        if (this.observers.length === 0 || this.token === undefined) {
+            return;
+        }
+        this.timeoutHandler = setTimeout(() => this.notifyTokenIsExpiring(), this.computeTimeoutTimeInMs());
+    }
+    /**
+     * Compute the timeout time in milliseconds.
+     */
+    computeTimeoutTimeInMs() {
+        const remainingSeconds = this.token.tokenRemainingSeconds;
+        let timeoutTimeInSeconds = remainingSeconds - this.limitInSeconds;
+        return timeoutTimeInSeconds < 0 ? 0 : timeoutTimeInSeconds * 1000;
+    }
+    /**
+     * Notify all observers that the token is expiring.
+     */
+    notifyTokenIsExpiring() {
+        this.observers.forEach((cb) => {
+            try {
+                cb.call(undefined, this.token);
+            }
+            catch (e) {
+                this.logger.error(e.message);
+            }
+        });
+    }
+}
+
+/**
+ * JwtManager class.
+ * It provides methods for managing JWT (Json Web Token), such as retrieving and refreshing.
+ *
+ * @template T The data type the JwtToken carries. Default to unknown.
+ * @template ExtraInfo The type of the optional extra information returned by the getJwt method. Defaults to undefined.
+ * @property {JwtRepository<T, ExtraInfo>} jwtRepository JwtRepository instance used for token management.
+ * @property {JwtResolver<ExtraInfo>} resolver JwtResolver instance used for token retrieval.
+ */
+class JwtManager {
+    /**
+     * Constructor for JwtManager class.
+     *
+     * @param {JwtRepository<T, ExtraInfo>} jwtRepository JwtRepository instance used for token management.
+     * @param {JwtResolver<ExtraInfo>} resolver JwtResolver instance used for token retrieval.
+     * @param {JwtManagerOptions} options JwtManagerOptions bag to customize behavior.
+     */
+    constructor(jwtRepository, resolver, options) {
+        this.jwtRepository = jwtRepository;
+        this.resolver = resolver;
+        if (options === null || options === void 0 ? void 0 : options.keepTokenUpdated) {
+            jwtRepository.subscribeToTokenNearExpiration(() => this.refreshToken());
+        }
+    }
+    /**
+     * Method to get a JWT token.
+     * If there's a token request in progress, it will return the Promise of this request.
+     * If the current token is undefined or expired, it will initiate a token refresh.
+     * Otherwise, it will return the current token.
+     *
+     * @returns {JwtToken<T, ExtraInfo> | Promise<JwtToken<T, ExtraInfo>>} The current token or the Promise of a token request.
+     */
+    getJwt() {
+        if (this.inflightPromise) {
+            return this.inflightPromise;
+        }
+        const token = this.jwtRepository.token;
+        if (token === undefined || token.isExpired) {
+            return this.refreshToken();
+        }
+        return token;
+    }
+    /**
+     * Method to refresh a JWT token.
+     * If a refresh request is already in progress, it will return the Promise of this request.
+     * Otherwise, it will start a new refresh request and return its Promise.
+     *
+     * @returns {Promise<JwtToken<T, ExtraInfo>>} Promise of the refreshed token.
+     */
+    refreshToken() {
+        if (this.inflightPromise === undefined) {
+            this.inflightPromise = new Promise((resolve, reject) => {
+                this.resolver
+                    .getJwt()
+                    .then(({ jwt, extraInfo }) => {
+                    this.inflightPromise = undefined;
+                    const token = this.jwtRepository.setToken(jwt, extraInfo);
+                    resolve(token);
+                })
+                    .catch((reason) => {
+                    this.inflightPromise = undefined;
+                    reject(reason);
+                });
+            });
+        }
+        return this.inflightPromise;
+    }
+    /**
+     * Method to check if a token refresh is in progress.
+     *
+     * @returns {boolean} true if a token refresh is in progress, false otherwise.
+     */
+    get isRefreshingToken() {
+        return this.inflightPromise !== undefined;
+    }
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+function buildServiceDescriptor(interceptors = { request: [] }) {
+    return {
+        type: 'fetch',
+        version: '1.0',
+        service: function (...args) {
+            const { request: requestInterceptors = [] } = interceptors;
+            const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(interceptor), resolvedPromiseLike(args));
+            return pending.then((args) => fetch(...args));
+        },
+    };
+}
+
+const UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE = 'Unexpected Authorization header encountered. To specify a custom Authorization header, use a Fetch service that is not configured with JwtRequestHeaderInterceptor';
+function setHeaderAuthorization({ token }, [resource, options = {}]) {
+    let hasAuthorizationHeaderBeenSet = false;
+    const Authorization = `Bearer ${token}`;
+    // The following is necessary because fetch(RequestInfo, options|RequestInit)
+    // does not merge properties from options|RequestInit.headers into RequestInfo.headers,
+    // instead it will pave over RequestInfo.headers if options|RequestInit.headers
+    // is defined. Therefore, this function must preserve any pre-existing headers
+    // properties across two different arguments that themselves may be four
+    // different data types.
+    //
+    // - a string
+    // - an instance of URL
+    // - an instance of Request
+    //
+    // And for this argument we only need to guard against overwriting an
+    // existing `headers` property whose value is an instance of Headers.
+    // This will only be valid when the resource argument is an instance of
+    // Request, which implicitly holds a property called `headers` whose
+    // value is an instance of Headers AND options has not been explicitly
+    // provided, or has but does not have a headers property. The existance
+    // of an explicit headers property would likely be intentional, so
+    // we defer to the calling code.
+    if (resource instanceof Request && !(options === null || options === void 0 ? void 0 : options.headers)) {
+        // If the resource object's headers instance already contains an
+        // "Authorization" header, then we have to assume this is a mistake
+        // so throw an exception that will result in the fetch call returning
+        // a rejected promise.
+        if (resource.headers.has('Authorization')) {
+            throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
+        }
+        // Otherwise, set the "Authorization" header with the provided
+        // JWT value (because options?.headers also doesn't exist)
+        resource.headers.set('Authorization', Authorization);
+        hasAuthorizationHeaderBeenSet = true;
+    }
+    // When the options object is provided, it may already have a
+    // `headers` property whose value is an instance of Headers, or
+    // a `headers` property that is a plain object comprised of key=>value
+    // pairs that will be converted into a Headers object by fetch().
+    //
+    // If the options object contains a property called `headers` whose value
+    // is an instance of Headers...
+    if ((options === null || options === void 0 ? void 0 : options.headers) instanceof Headers) {
+        // ...Check to see if that object contains an "Authorization" header.
+        // If it does, then we have to assume this is a mistake so throw an
+        // exception.
+        if (options === null || options === void 0 ? void 0 : options.headers.has('Authorization')) {
+            throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
+        }
+        // Otherwise, set the "Authorization" header with the provided
+        // JWT token value:
+        options === null || options === void 0 ? void 0 : options.headers.set('Authorization', Authorization);
+    }
+    else {
+        // Else, check if options contains a `headers` property whose value
+        // is a plain object comprised of key=>value pairs. If this
+        // object contains a property called "Authorization", then we have
+        // to assume this is a mistake so throw an exception.
+        if ((options === null || options === void 0 ? void 0 : options.headers) && Reflect.has(options === null || options === void 0 ? void 0 : options.headers, 'Authorization')) {
+            throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
+        }
+        // Otherwise, add a property called "Authorization", whose value is
+        // the provided JWT value, as long as it has not been set on Request
+        if (!hasAuthorizationHeaderBeenSet) {
+            options.headers = {
+                ...options === null || options === void 0 ? void 0 : options.headers,
+                Authorization,
+            };
+        }
+    }
+    return [resource, options];
+}
+function buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier = (_e, fetchArgs) => fetchArgs) {
+    return (args) => {
+        return resolvedPromiseLike(jwtManager.getJwt()).then((token) => {
+            const fetchArgsWithRequestHeaderAuthorization = setHeaderAuthorization(token, args);
+            return token.extraInfo
+                ? jwtRequestModifier(token.extraInfo, fetchArgsWithRequestHeaderAuthorization)
+                : fetchArgsWithRequestHeaderAuthorization;
+        });
+    };
+}
+
+const SFAP_EXCHANGE_PATH = '/webruntime/sfap-info';
+/**
+ * We expect jwt info and baseUri to be present in the response.
+ *
+ * @param response
+ */
+function validateResponse(response) {
+    if (!response || !response.jwt || !response.baseUri) {
+        // wrapped the invocation in env conditional
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`Expected jwt info and baseUri to be present but instead got: ${JSON.stringify(response)}`);
+    }
+}
+/**
+ * Resolves Jwt token for SFAP by calling Aura action
+ * {@link JwtResolver} for platform SFAP
+ */
+const platformSfapJwtResolver = {
+    getJwt() {
+        return new Promise((resolve, reject) => {
+            fetch(SFAP_EXCHANGE_PATH)
+                .then((res) => res.json())
+                .then((response) => {
+                if (process.env.NODE_ENV !== 'production') {
+                    validateResponse(response);
+                }
+                resolve({
+                    jwt: response.jwt,
+                    extraInfo: {
+                        baseUri: response.baseUri,
+                    },
+                });
+            })
+                .catch((error) => {
+                if (error instanceof Error) {
+                    reject(error.message);
+                    return;
+                }
+                // AuraFetchResponse errors
+                const { status } = error;
+                if (status !== HttpStatusCode$2.ServerError) {
+                    // ConnectInJavaError
+                    reject(error.body.message);
+                    return;
+                }
+                reject(error.body.error);
+            });
+        });
+    },
+};
+
+const SFAP_BASE_URL = 'api.salesforce.com';
+const sfapJwtRepository = new JwtRepository();
+const sfapJwtManager = new JwtManager(sfapJwtRepository, platformSfapJwtResolver);
+function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
+    const jwtAuthorizedFetchService = buildServiceDescriptor({
+        request: [buildJwtRequestInterceptor(logger)],
+    });
+    return {
+        ...jwtAuthorizedFetchService,
+        tags: { authenticationScopes: 'sfap_api' },
+    };
+}
+/**
+ * Returns a service descriptor for a fetch service that includes one-off copilot
+ * hacks. This fetch service is not intended for use by anything other than
+ * copilot commands.
+ */
+function buildCopilotFetchServiceDescriptor(logger) {
+    return {
+        // Note that this layers the Interceptor below directly on top of fetch(). WHen
+        // we switch to JWT authentication this will need to change to incorporate the
+        // Interceptor here with the logic in buildJwtAuthorizedSfapFetchServiceDescriptor()
+        // above.
+        ...buildServiceDescriptor({
+            request: [
+                // Note that this function is VERY closely tied to the fetchParams generated
+                // by copilotStartSessionCommand. Any changes to those parameters will require
+                // corresponding updates to the logic below.
+                (args) => {
+                    const [url, requestInit] = args;
+                    // ignore anything other than a start session request
+                    if (typeof url !== 'string' ||
+                        !url.endsWith('/sessions') ||
+                        !requestInit ||
+                        requestInit.method !== 'POST' ||
+                        !requestInit.body ||
+                        typeof requestInit.body !== 'string') {
+                        return resolvedPromiseLike(args);
+                    }
+                    return resolvedPromiseLike(sfapJwtManager.getJwt()).then((token) => {
+                        // replace the body's instanceConfig.endpoint with the JWT's iss value
+                        const body = JSON.parse(requestInit.body);
+                        if (!body || !token.decodedInfo || !token.decodedInfo.iss) {
+                            logger.warn('skipping injection of endpoint into start session request');
+                        }
+                        else {
+                            if (!body.instanceConfig) {
+                                body.instanceConfig = {};
+                            }
+                            body.instanceConfig.endpoint = token.decodedInfo.iss;
+                        }
+                        return [
+                            args[0],
+                            {
+                                ...args[1],
+                                body: JSON.stringify(body),
+                            },
+                        ];
+                    });
+                },
+                buildJwtRequestInterceptor(logger),
+            ],
+        }),
+        tags: { specialHacksFor: 'copilot' },
+    };
+}
+function buildUnauthorizedFetchServiceDescriptor() {
+    const fetchService = buildServiceDescriptor();
+    return {
+        ...fetchService,
+        tags: { authenticationScopes: '' },
+    };
+}
+function buildJwtRequestInterceptor(logger) {
+    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('SFAP fetch service expects a string or URL resource');
+            }
+            return [resource, request];
+        }
+        const overrideUrl = new URL(baseUri);
+        const url = typeof resource === 'string' ? new URL(resource) : new URL(resource.toString());
+        if (!(url.host === SFAP_BASE_URL)) {
+            logger.warn(`SFAP fetch service requires that the host of the resource is ${SFAP_BASE_URL}`);
+            return [resource, request];
+        }
+        url.host = overrideUrl.host;
+        url.protocol = overrideUrl.protocol;
+        return [url, request];
+    };
+    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(sfapJwtManager, jwtRequestModifier);
+    return jwtRequestHeaderInterceptor;
+}
+
+// Initializes OneStore in Webruntime
+function initOneStore() {
+    const loggerService = new ConsoleLogger$1('ERROR');
+    const cacheServiceDescriptor = buildServiceDescriptor$4();
+    const instrumentationServiceDescriptor = buildServiceDescriptor$5(loggerService);
+    const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
+    const services = [
+        instrumentationServiceDescriptor,
+        buildUnauthorizedFetchServiceDescriptor(),
+        buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
+        buildCopilotFetchServiceDescriptor(loggerService),
+        buildAuraNetworkService(),
+        buildServiceDescriptor$6(instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$3(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service),
+        buildServiceDescriptor$d(),
+        buildServiceDescriptor$1(),
+        buildServiceDescriptor$9(),
+        buildServiceDescriptor$e(),
+        buildServiceDescriptor$8(),
+        buildServiceDescriptor$7(),
+        buildServiceDescriptor$c(),
+        buildServiceDescriptor$b(),
+        buildServiceDescriptor$a(),
+        buildServiceDescriptor$2(),
+    ];
+    setServices(services);
+}
+function buildAuraNetworkService() {
+    return {
+        type: 'auraNetwork',
+        version: '1.0',
+        service: executeGlobalControllerRawResponse,
+    };
+}
+
+export { initOneStore };
+// version: 1.360.0-580249acee