@salesforce/lds-runtime-aura 1.100.2

package/LICENSE.txt

@@ -0,0 +1,82 @@
+Terms of Use
+
+Copyright 2022 Salesforce, Inc. All rights reserved.
+
+These Terms of Use govern the download, installation, and/or use of this
+software provided by Salesforce, Inc. ("Salesforce") (the "Software"), were
+last updated on April 15, 2022, and constitute a legally binding
+agreement between you and Salesforce. If you do not agree to these Terms of
+Use, do not install or use the Software.
+
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free
+copyright license to reproduce, prepare derivative works of, publicly
+display, publicly perform, sublicense, and distribute the Software and
+derivative works subject to these Terms. These Terms shall be included in
+all copies or substantial portions of the Software.
+
+Subject to the limited rights expressly granted hereunder, Salesforce
+reserves all rights, title, and interest in and to all intellectual
+property subsisting in the Software. No rights are granted to you hereunder
+other than as expressly set forth herein. Users residing in countries on
+the United States Office of Foreign Assets Control sanction list, or which
+are otherwise subject to a US export embargo, may not use the Software.
+
+Implementation of the Software may require development work, for which you
+are responsible. The Software may contain bugs, errors and
+incompatibilities and is made available on an AS IS basis without support,
+updates, or service level commitments.
+
+Salesforce reserves the right at any time to modify, suspend, or
+discontinue, the Software (or any part thereof) with or without notice. You
+agree that Salesforce shall not be liable to you or to any third party for
+any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or
+proceeding made or brought against Salesforce by a third party arising out
+of or accruing from (a) your use of the Software, and (b) any application
+you develop with the Software that infringes any copyright, trademark,
+trade secret, trade dress, patent, or other intellectual property right of
+any person or defames any person or violates their rights of publicity or
+privacy (each a "Claim Against Salesforce"), and will indemnify Salesforce
+from any damages, attorney fees, and costs finally awarded against
+Salesforce as a result of, or for any amounts paid by Salesforce under a
+settlement approved by you in writing of, a Claim Against Salesforce,
+provided Salesforce (x) promptly gives you written notice of the Claim
+Against Salesforce, (y) gives you sole control of the defense and
+settlement of the Claim Against Salesforce (except that you may not settle
+any Claim Against Salesforce unless it unconditionally releases Salesforce
+of all liability), and (z) gives you all reasonable assistance, at your
+expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT
+SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES,
+INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
+PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA,
+OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN
+CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+These Terms of Use shall be governed exclusively by the internal laws of
+the State of California, without regard to its conflicts of laws
+rules. Each party hereby consents to the exclusive jurisdiction of the
+state and federal courts located in San Francisco County, California to
+adjudicate any dispute arising out of or relating to these Terms of Use and
+the download, installation, and/or use of the Software. Except as expressly
+stated herein, these Terms of Use constitute the entire agreement between
+the parties, and supersede all prior and contemporaneous agreements,
+proposals, or representations, written or oral, concerning their subject
+matter. No modification, amendment, or waiver of any provision of these
+Terms of Use shall be effective unless it is by an update to these Terms of
+Use that Salesforce makes available, or is in writing and signed by the
+party against whom the modification, amendment, or waiver is to be
+asserted.
+
+Data Privacy: Salesforce may collect, process, and store device,
+system, and other information related to your use of the Software. This
+information includes, but is not limited to, IP address, user metrics, and
+other data ("Usage Data"). Salesforce may use Usage Data for analytics,
+product development, and marketing purposes. You acknowledge that files
+generated in conjunction with the Software may contain sensitive or
+confidential data, and you are solely responsible for anonymizing and
+protecting such data.

package/dist/__mocks__/@salesforce/gate/lds.useNewTrackedFieldBehavior.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    isOpen: () => boolean;
+};
+export default _default;

package/dist/__mocks__/@salesforce/lds-ads-bridge.d.ts

@@ -0,0 +1,2 @@
+export default function (): void;
+export declare function instrument(): void;

package/dist/__mocks__/@salesforce/lds-aura-storage.d.ts

@@ -0,0 +1 @@
+export declare function clearStorages(): Promise<void>;

package/dist/__mocks__/@salesforce/lds-instrumentation.d.ts

@@ -0,0 +1,9 @@
+export declare function setupInstrumentation(): void;
+export declare function LRUCache(): Map<any, any>;
+export declare function incrementCounterMetric(): void;
+export declare function updatePercentileHistogramMetric(): void;
+export declare function instrumentAdapter<_C, _D>(adapter: any, _metadata: any): any;
+export declare function instrumentLuvio(): void;
+export declare function instrumentStoreMethods(): void;
+export declare function setLdsAdaptersUiapiInstrumentation(): void;
+export declare function setLdsNetworkAdapterInstrumentation(): void;

package/dist/__mocks__/@salesforce/lds-network-aura.d.ts

@@ -0,0 +1,2 @@
+export default function (): void;
+export declare function instrument(): void;

package/dist/__mocks__/force/ldsGraphqlParser.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jest" />
+declare const astResolver: jest.Mock<any, any>;
+export { astResolver };

package/dist/__mocks__/instrumentation/service.d.ts

@@ -0,0 +1,33 @@
+export declare function counter(): {
+    increment(): void;
+    decrement(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function gauge(): {
+    setValue(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function mark(): void;
+export declare function markStart(): void;
+export declare function markEnd(): void;
+export declare function perfStart(): void;
+export declare function perfEnd(): void;
+export declare function percentileHistogram(): {
+    update(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function time(): void;
+export declare function timer(): {
+    addDuration(): void;
+    getValue(): void;
+    time(): void;
+};
+export declare function registerCacheStats(): {
+    logHits(): void;
+    logMisses(): void;
+};
+export declare function registerPlugin(): void;
+export declare function registerPeriodicLogger(): void;

package/dist/aura-instrumentation/main.d.ts

@@ -0,0 +1,178 @@
+import type { FetchResponse, Luvio, InMemoryStore, Adapter, UnfulfilledSnapshot } from '@luvio/engine';
+import type { AdapterMetadata } from '@salesforce/lds-bindings';
+import { ADAPTER_UNFULFILLED_ERROR } from '@salesforce/lds-bindings';
+import type { CacheStatsLogger, Timer } from 'instrumentation/service';
+export interface AdapterUnfulfilledError {
+    [ADAPTER_UNFULFILLED_ERROR]: boolean;
+    adapterName: string;
+    missingPaths: UnfulfilledSnapshot<any, any>['missingPaths'];
+    missingLinks: UnfulfilledSnapshot<any, any>['missingLinks'];
+}
+export declare const APEX_ADAPTER_NAME = "getApex";
+export declare const NORMALIZED_APEX_ADAPTER_NAME: string;
+export declare const REFRESH_APEX_KEY = "refreshApex";
+export declare const REFRESH_UIAPI_KEY = "refreshUiApi";
+export declare const SUPPORTED_KEY = "refreshSupported";
+export declare const UNSUPPORTED_KEY = "refreshUnsupported";
+type refreshApiNames = {
+    refreshApex: string;
+    refreshUiApi: string;
+};
+export interface LightningInteractionSchema {
+    target: string;
+    scope: string;
+    context: unknown;
+    eventSource: string;
+    eventType: string;
+    attributes: unknown;
+}
+export declare class Instrumentation {
+    private adapterUnfulfilledErrorCounters;
+    private recordApiNameChangeCounters;
+    private refreshAdapterEvents;
+    private refreshApiCallEventStats;
+    private lastRefreshApiCall;
+    private weakEtagZeroEvents;
+    private adapterCacheMisses;
+    constructor();
+    /**
+     * Instruments an existing adapter to log argus metrics and cache stats.
+     * @param adapter The adapter function.
+     * @param metadata The adapter metadata.
+     * @param wireConfigKeyFn Optional function to transform wire configs to a unique key.
+     * @returns The wrapped adapter.
+     */
+    instrumentAdapter<C, D>(adapter: Adapter<C, D>, metadata: AdapterMetadata): Adapter<C, D>;
+    /**
+     * Logs when adapter requests come in. If we have subsequent cache misses on a given config, beyond its TTL then log the duration to metrics.
+     * Backed by an LRU Cache implementation to prevent too many record entries from being stored in-memory.
+     * @param name The wire adapter name.
+     * @param config The config passed into wire adapter.
+     * @param ttlMissStats CacheStatsLogger to log misses out of TTL.
+     * @param currentCacheMissTimestamp Timestamp for when the request was made.
+     * @param ttl TTL for the wire adapter.
+     */
+    private logAdapterCacheMissOutOfTtlDuration;
+    /**
+     * Injected to LDS for Luvio specific instrumentation.
+     *
+     * @param context The transaction context.
+     */
+    instrumentLuvio(context: unknown): void;
+    /**
+     * Returns whether or not this is a RefreshAdapterEvent.
+     * @param context The transaction context.
+     * @returns Whether or not this is a RefreshAdapterEvent.
+     */
+    private isRefreshAdapterEvent;
+    /**
+     * Returns whether or not this is an AdapterUnfulfilledError.
+     * @param context The transaction context.
+     * @returns Whether or not this is an AdapterUnfulfilledError.
+     */
+    private isAdapterUnfulfilledError;
+    /**
+     * Specific instrumentation for getRecordNotifyChange.
+     * temporary implementation to match existing aura call for now
+     *
+     * @param uniqueWeakEtags whether weakEtags match or not
+     * @param error if dispatchResourceRequest fails for any reason
+     */
+    notifyChangeNetwork(uniqueWeakEtags: boolean | null, error?: boolean): void;
+    /**
+     * Parses and aggregates weakETagZero events to be sent in summarized log line.
+     * @param context The transaction context.
+     */
+    aggregateWeakETagEvents(incomingWeakEtagZero: boolean, existingWeakEtagZero: boolean, apiName: string): void;
+    /**
+     * Aggregates refresh adapter events to be sent in summarized log line.
+     *   - how many times refreshApex is called
+     *   - how many times refresh from lightning/uiRecordApi is called
+     *   - number of supported calls: refreshApex called on apex adapter
+     *   - number of unsupported calls: refreshApex on non-apex adapter
+     *          + any use of refresh from uiRecordApi module
+     *   - count of refresh calls per adapter
+     * @param context The refresh adapter event.
+     */
+    private aggregateRefreshAdapterEvents;
+    /**
+     * Increments call stat for incoming refresh api call, and sets the name
+     * to be used in {@link aggregateRefreshCalls}
+     * @param from The name of the refresh function called.
+     */
+    handleRefreshApiCall(apiName: keyof refreshApiNames): void;
+    /**
+     * W-7302241
+     * Logs refresh call summary stats as a LightningInteraction.
+     */
+    logRefreshStats(): void;
+    /**
+     * Resets the stat trackers for refresh call events.
+     */
+    private resetRefreshStats;
+    /**
+     * W-7801618
+     * Counter for occurrences where the incoming record to be merged has a different apiName.
+     * Dynamically generated metric, stored in an {@link RecordApiNameChangeCounters} object.
+     *
+     * @param context The transaction context.
+     *
+     * Note: Short-lived metric candidate, remove at the end of 230
+     */
+    incrementRecordApiNameChangeCount(_incomingApiName: string, existingApiName: string): void;
+    /**
+     * W-8620679
+     * Increment the counter for an UnfulfilledSnapshotError coming from luvio
+     *
+     * @param context The transaction context.
+     */
+    private incrementAdapterRequestErrorCount;
+}
+/**
+ * Calls instrumentation/service interaction API. Function name and parameters mapped to `o11y`
+ * implementation for Log Lines.
+ * @param schema Expected shape of the payload (Currently unused)
+ * @param payload Content to be logged, shape matches schema
+ */
+export declare function log(_schema: any, payload: LightningInteractionSchema): void;
+/**
+ * Calls instrumentation/service telemetry timer
+ * @param name Name of the metric
+ * @param duration number to update backing percentile histogram, negative numbers ignored
+ */
+export declare function updateTimerMetric(name: string, duration: number): void;
+export declare function timerMetricAddDuration(timer: Timer, duration: number): void;
+export declare function incrementRequestResponseCount(cb: () => FetchResponse<unknown>): void;
+/**
+ * Add a mark to the metrics service.
+ *
+ * @param name The mark name.
+ * @param content The mark content.
+ */
+export declare function mark(name: string, content?: any): void;
+/**
+ * Create a new instrumentation cache stats and return it.
+ *
+ * @param name The cache logger name.
+ */
+export declare function registerLdsCacheStats(name: string): CacheStatsLogger;
+/**
+ * Add or overwrite hooks that require aura implementations
+ */
+export declare function setAuraInstrumentationHooks(): void;
+/**
+ * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
+ *
+ * @param luvio The Luvio instance to instrument.
+ * @param store The InMemoryStore to instrument.
+ */
+export declare function setupInstrumentation(luvio: Luvio, store: InMemoryStore): void;
+/**
+ * Note: locator.scope is set to 'force_record' in order for the instrumentation gate to work, which will
+ * disable all crud operations if it is on.
+ * @param eventSource - Source of the logging event.
+ * @param attributes - Free form object of attributes to log.
+ */
+export declare function logCRUDLightningInteraction(eventSource: string, attributes: object): void;
+export declare const instrumentation: Instrumentation;
+export {};

package/dist/aura-instrumentation/utils/language.d.ts

@@ -0,0 +1,13 @@
+declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+declare const isArray: (arg: any) => arg is any[];
+declare const stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+export { create as ObjectCreate, keys as ObjectKeys, isArray as ArrayIsArray, stringify as JSONStringify, };

package/dist/aura-instrumentation/utils/observability.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Observability / Critical Availability Program (230+)
+ *
+ * This file is intended to be used as a consolidated place for all definitions, functions,
+ * and helpers related to "M1"[1].
+ *
+ * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
+ *
+ * [1] https://salesforce.quip.com/NfW9AsbGEaTY
+ * [2] https://salesforce.quip.com/1dFvAba1b0eq
+ */
+import type { MetricsKey } from 'instrumentation/service';
+export declare const OBSERVABILITY_NAMESPACE = "LIGHTNING.lds.service";
+export declare const ADAPTER_INVOCATION_COUNT_METRIC_NAME = "request";
+export declare const ADAPTER_ERROR_COUNT_METRIC_NAME = "error";
+export declare const NETWORK_ADAPTER_RESPONSE_METRIC_NAME = "network-response";
+/**
+ * W-8379680
+ * Counter for number of getApex requests.
+ */
+export declare const GET_APEX_REQUEST_COUNT: MetricsKey;
+/**
+ * W-8379680
+ * Counter for number of getApex errors.
+ */
+export declare const GET_APEX_ERROR_COUNT: MetricsKey;
+/**
+ * W-8828410
+ * Counter for the number of UnfulfilledSnapshotErrors the luvio engine has.
+ */
+export declare const TOTAL_ADAPTER_ERROR_COUNT: MetricsKey;
+/**
+ * W-8828410
+ * Counter for the number of invocations made into LDS by a wire adapter.
+ */
+export declare const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT: MetricsKey;

package/dist/aura-instrumentation/utils/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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}"
+ * Modified from the apex implementation to sort arrays non-destructively.
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+export declare function stableJSONStringify(node: any): string | undefined;
+export declare function isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;

package/dist/ldsEngineCreator.js

@@ -0,0 +1,682 @@
+/**
+ * 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 { InMemoryStore, Environment, Luvio, InMemoryStoreQueryEvaluator } from 'force/luvioEngine';
+import ldsTrackedFieldsBehaviorGate from '@salesforce/gate/lds.useNewTrackedFieldBehavior';
+import { instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType } from 'force/ldsAdaptersUiapi';
+import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
+import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$2 } from 'force/ldsBindings';
+import { counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, mark as mark$1, timer } from 'instrumentation/service';
+import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from 'force/ldsInstrumentation';
+import networkAdapter, { instrument as instrument$1, forceRecordTransactionsDisabled, ldsNetworkAdapterInstrument } from 'force/ldsNetwork';
+import { instrument as instrument$3 } from 'force/adsBridge';
+import { clearStorages } from 'force/ldsStorage';
+
+/**
+ * Observability / Critical Availability Program (230+)
+ *
+ * This file is intended to be used as a consolidated place for all definitions, functions,
+ * and helpers related to "M1"[1].
+ *
+ * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
+ *
+ * [1] https://salesforce.quip.com/NfW9AsbGEaTY
+ * [2] https://salesforce.quip.com/1dFvAba1b0eq
+ */
+const OBSERVABILITY_NAMESPACE = 'LIGHTNING.lds.service';
+const ADAPTER_INVOCATION_COUNT_METRIC_NAME = 'request';
+const ADAPTER_ERROR_COUNT_METRIC_NAME = 'error';
+const NETWORK_ADAPTER_RESPONSE_METRIC_NAME = 'network-response';
+/**
+ * W-8379680
+ * Counter for number of getApex requests.
+ */
+const GET_APEX_REQUEST_COUNT = {
+    get() {
+        return {
+            owner: OBSERVABILITY_NAMESPACE,
+            name: ADAPTER_INVOCATION_COUNT_METRIC_NAME + '.' + NORMALIZED_APEX_ADAPTER_NAME,
+        };
+    },
+};
+/**
+ * W-8828410
+ * Counter for the number of UnfulfilledSnapshotErrors the luvio engine has.
+ */
+const TOTAL_ADAPTER_ERROR_COUNT = {
+    get() {
+        return { owner: OBSERVABILITY_NAMESPACE, name: ADAPTER_ERROR_COUNT_METRIC_NAME };
+    },
+};
+/**
+ * W-8828410
+ * Counter for the number of invocations made into LDS by a wire adapter.
+ */
+const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = {
+    get() {
+        return { owner: OBSERVABILITY_NAMESPACE, name: ADAPTER_INVOCATION_COUNT_METRIC_NAME };
+    },
+};
+
+const { create, keys } = Object;
+const { isArray } = Array;
+const { stringify } = JSON;
+
+/**
+ * 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}"
+ * Modified from the apex implementation to sort arrays non-destructively.
+ * @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)) {
+        // copy any array before sorting so we don't mutate the object.
+        // eslint-disable-next-line no-param-reassign
+        node = node.slice(0).sort();
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify(node[i]) || 'null';
+        }
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const keys$1 = keys(node).sort();
+    out = '';
+    for (i = 0; i < keys$1.length; i++) {
+        const key = keys$1[i];
+        const value = stableJSONStringify(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += stringify(key) + ':' + value;
+    }
+    return '{' + out + '}';
+}
+function isPromise(value) {
+    // check for Thenable due to test frameworks using custom Promise impls
+    return value !== null && value.then !== undefined;
+}
+
+const APEX_ADAPTER_NAME = 'getApex';
+const NORMALIZED_APEX_ADAPTER_NAME = `Apex.${APEX_ADAPTER_NAME}`;
+const REFRESH_APEX_KEY = 'refreshApex';
+const REFRESH_UIAPI_KEY = 'refreshUiApi';
+const SUPPORTED_KEY = 'refreshSupported';
+const UNSUPPORTED_KEY = 'refreshUnsupported';
+const REFRESH_EVENTSOURCE = 'lds-refresh-summary';
+const REFRESH_EVENTTYPE = 'system';
+const REFRESH_PAYLOAD_TARGET = 'adapters';
+const REFRESH_PAYLOAD_SCOPE = 'lds';
+const INCOMING_WEAKETAG_0_KEY = 'incoming-weaketag-0';
+const EXISTING_WEAKETAG_0_KEY = 'existing-weaketag-0';
+const RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME = 'record-api-name-change-count';
+const NAMESPACE = 'lds';
+const NETWORK_TRANSACTION_NAME = 'lds-network';
+const CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX = 'out-of-ttl-miss';
+// Aggregate Cache Stats and Metrics for all getApex invocations
+const getApexCacheStats = registerLdsCacheStats(NORMALIZED_APEX_ADAPTER_NAME);
+const getApexTtlCacheStats = registerLdsCacheStats(NORMALIZED_APEX_ADAPTER_NAME + ':' + CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX);
+// Observability (READS)
+const getApexRequestCountMetric = counter(GET_APEX_REQUEST_COUNT);
+const totalAdapterRequestSuccessMetric = counter(TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT);
+const totalAdapterErrorMetric = counter(TOTAL_ADAPTER_ERROR_COUNT);
+class Instrumentation {
+    constructor() {
+        this.adapterUnfulfilledErrorCounters = {};
+        this.recordApiNameChangeCounters = {};
+        this.refreshAdapterEvents = {};
+        this.refreshApiCallEventStats = {
+            [REFRESH_APEX_KEY]: 0,
+            [REFRESH_UIAPI_KEY]: 0,
+            [SUPPORTED_KEY]: 0,
+            [UNSUPPORTED_KEY]: 0,
+        };
+        this.lastRefreshApiCall = null;
+        this.weakEtagZeroEvents = {};
+        this.adapterCacheMisses = new LRUCache(250);
+        if (typeof window !== 'undefined' && window.addEventListener) {
+            window.addEventListener('beforeunload', () => {
+                if (keys(this.weakEtagZeroEvents).length > 0) {
+                    perfStart(NETWORK_TRANSACTION_NAME);
+                    perfEnd(NETWORK_TRANSACTION_NAME, this.weakEtagZeroEvents);
+                }
+            });
+        }
+        registerPeriodicLogger(NAMESPACE, this.logRefreshStats.bind(this));
+    }
+    /**
+     * Instruments an existing adapter to log argus metrics and cache stats.
+     * @param adapter The adapter function.
+     * @param metadata The adapter metadata.
+     * @param wireConfigKeyFn Optional function to transform wire configs to a unique key.
+     * @returns The wrapped adapter.
+     */
+    instrumentAdapter(adapter, metadata) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        const { apiFamily, name, ttl } = metadata;
+        const adapterName = normalizeAdapterName(name, apiFamily);
+        const isGetApexAdapter = isApexAdapter(name);
+        const stats = isGetApexAdapter ? getApexCacheStats : registerLdsCacheStats(adapterName);
+        const ttlMissStats = isGetApexAdapter
+            ? getApexTtlCacheStats
+            : registerLdsCacheStats(adapterName + ':' + CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX);
+        /**
+         * W-8076905
+         * Dynamically generated metric. Simple counter for all requests made by this adapter.
+         */
+        const wireAdapterRequestMetric = isGetApexAdapter
+            ? getApexRequestCountMetric
+            : counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_INVOCATION_COUNT_METRIC_NAME, adapterName));
+        const instrumentedAdapter = (config, requestContext) => {
+            // increment overall and adapter request metrics
+            wireAdapterRequestMetric.increment(1);
+            totalAdapterRequestSuccessMetric.increment(1);
+            // execute adapter logic
+            const result = adapter(config, requestContext);
+            // In the case where the adapter returns a non-Pending Snapshot it is constructed out of the store
+            // (cache hit) whereas a Promise<Snapshot> or Pending Snapshot indicates a network request (cache miss).
+            //
+            // Note: we can't do a plain instanceof check for a promise here since the Promise may
+            // originate from another javascript realm (for example: in jest test). Instead we use a
+            // duck-typing approach by checking if the result has a then property.
+            //
+            // For adapters without persistent store:
+            //  - total cache hit ratio:
+            //      [in-memory cache hit count] / ([in-memory cache hit count] + [in-memory cache miss count])
+            // For adapters with persistent store:
+            //  - in-memory cache hit ratio:
+            //      [in-memory cache hit count] / ([in-memory cache hit count] + [in-memory cache miss count])
+            //  - total cache hit ratio:
+            //      ([in-memory cache hit count] + [store cache hit count]) / ([in-memory cache hit count] + [in-memory cache miss count])
+            // if result === null then config is insufficient/invalid so do not log
+            if (isPromise(result)) {
+                stats.logMisses();
+                if (ttl !== undefined) {
+                    this.logAdapterCacheMissOutOfTtlDuration(adapterName, config, ttlMissStats, Date.now(), ttl);
+                }
+            }
+            else if (result !== null) {
+                stats.logHits();
+            }
+            return result;
+        };
+        // Set the name property on the function for debugging purposes.
+        Object.defineProperty(instrumentedAdapter, 'name', {
+            value: name + '__instrumented',
+        });
+        return instrumentAdapter(instrumentedAdapter, metadata);
+    }
+    /**
+     * Logs when adapter requests come in. If we have subsequent cache misses on a given config, beyond its TTL then log the duration to metrics.
+     * Backed by an LRU Cache implementation to prevent too many record entries from being stored in-memory.
+     * @param name The wire adapter name.
+     * @param config The config passed into wire adapter.
+     * @param ttlMissStats CacheStatsLogger to log misses out of TTL.
+     * @param currentCacheMissTimestamp Timestamp for when the request was made.
+     * @param ttl TTL for the wire adapter.
+     */
+    logAdapterCacheMissOutOfTtlDuration(name, config, ttlMissStats, currentCacheMissTimestamp, ttl) {
+        const configKey = `${name}:${stableJSONStringify(config)}`;
+        const existingCacheMissTimestamp = this.adapterCacheMisses.get(configKey);
+        this.adapterCacheMisses.set(configKey, currentCacheMissTimestamp);
+        if (existingCacheMissTimestamp !== undefined) {
+            const duration = currentCacheMissTimestamp - existingCacheMissTimestamp;
+            if (duration > ttl) {
+                ttlMissStats.logMisses();
+            }
+        }
+    }
+    /**
+     * Injected to LDS for Luvio specific instrumentation.
+     *
+     * @param context The transaction context.
+     */
+    instrumentLuvio(context) {
+        instrumentLuvio(context);
+        if (this.isRefreshAdapterEvent(context)) {
+            this.aggregateRefreshAdapterEvents(context);
+        }
+        else if (this.isAdapterUnfulfilledError(context)) {
+            this.incrementAdapterRequestErrorCount(context);
+        }
+        else ;
+    }
+    /**
+     * Returns whether or not this is a RefreshAdapterEvent.
+     * @param context The transaction context.
+     * @returns Whether or not this is a RefreshAdapterEvent.
+     */
+    isRefreshAdapterEvent(context) {
+        return context[REFRESH_ADAPTER_EVENT] === true;
+    }
+    /**
+     * Returns whether or not this is an AdapterUnfulfilledError.
+     * @param context The transaction context.
+     * @returns Whether or not this is an AdapterUnfulfilledError.
+     */
+    isAdapterUnfulfilledError(context) {
+        return context[ADAPTER_UNFULFILLED_ERROR] === true;
+    }
+    /**
+     * Specific instrumentation for getRecordNotifyChange.
+     * temporary implementation to match existing aura call for now
+     *
+     * @param uniqueWeakEtags whether weakEtags match or not
+     * @param error if dispatchResourceRequest fails for any reason
+     */
+    notifyChangeNetwork(uniqueWeakEtags, error) {
+        perfStart(NETWORK_TRANSACTION_NAME);
+        if (error === true) {
+            perfEnd(NETWORK_TRANSACTION_NAME, { 'notify-change-network': 'error' });
+        }
+        else {
+            perfEnd(NETWORK_TRANSACTION_NAME, { 'notify-change-network': uniqueWeakEtags });
+        }
+    }
+    /**
+     * Parses and aggregates weakETagZero events to be sent in summarized log line.
+     * @param context The transaction context.
+     */
+    aggregateWeakETagEvents(incomingWeakEtagZero, existingWeakEtagZero, apiName) {
+        const key = 'weaketag-0-' + apiName;
+        if (this.weakEtagZeroEvents[key] === undefined) {
+            this.weakEtagZeroEvents[key] = {
+                [EXISTING_WEAKETAG_0_KEY]: 0,
+                [INCOMING_WEAKETAG_0_KEY]: 0,
+            };
+        }
+        if (existingWeakEtagZero) {
+            this.weakEtagZeroEvents[key][EXISTING_WEAKETAG_0_KEY] += 1;
+        }
+        if (incomingWeakEtagZero) {
+            this.weakEtagZeroEvents[key][INCOMING_WEAKETAG_0_KEY] += 1;
+        }
+    }
+    /**
+     * Aggregates refresh adapter events to be sent in summarized log line.
+     *   - how many times refreshApex is called
+     *   - how many times refresh from lightning/uiRecordApi is called
+     *   - number of supported calls: refreshApex called on apex adapter
+     *   - number of unsupported calls: refreshApex on non-apex adapter
+     *          + any use of refresh from uiRecordApi module
+     *   - count of refresh calls per adapter
+     * @param context The refresh adapter event.
+     */
+    aggregateRefreshAdapterEvents(context) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        // Adding additional logging that getApex adapters can invoke? Read normalizeAdapterName ts-doc.
+        const adapterName = normalizeAdapterName(context.adapterName);
+        if (this.lastRefreshApiCall === REFRESH_APEX_KEY) {
+            if (isApexAdapter(adapterName)) {
+                this.refreshApiCallEventStats[SUPPORTED_KEY] += 1;
+            }
+            else {
+                this.refreshApiCallEventStats[UNSUPPORTED_KEY] += 1;
+            }
+        }
+        else if (this.lastRefreshApiCall === REFRESH_UIAPI_KEY) {
+            this.refreshApiCallEventStats[UNSUPPORTED_KEY] += 1;
+        }
+        if (this.refreshAdapterEvents[adapterName] === undefined) {
+            this.refreshAdapterEvents[adapterName] = 0;
+        }
+        this.refreshAdapterEvents[adapterName] += 1;
+        this.lastRefreshApiCall = null;
+    }
+    /**
+     * Increments call stat for incoming refresh api call, and sets the name
+     * to be used in {@link aggregateRefreshCalls}
+     * @param from The name of the refresh function called.
+     */
+    handleRefreshApiCall(apiName) {
+        this.refreshApiCallEventStats[apiName] += 1;
+        // set function call to be used with aggregateRefreshCalls
+        this.lastRefreshApiCall = apiName;
+    }
+    /**
+     * W-7302241
+     * Logs refresh call summary stats as a LightningInteraction.
+     */
+    logRefreshStats() {
+        if (keys(this.refreshAdapterEvents).length > 0) {
+            interaction(REFRESH_PAYLOAD_TARGET, REFRESH_PAYLOAD_SCOPE, this.refreshAdapterEvents, REFRESH_EVENTSOURCE, REFRESH_EVENTTYPE, this.refreshApiCallEventStats);
+            this.resetRefreshStats();
+        }
+    }
+    /**
+     * Resets the stat trackers for refresh call events.
+     */
+    resetRefreshStats() {
+        this.refreshAdapterEvents = {};
+        this.refreshApiCallEventStats = {
+            [REFRESH_APEX_KEY]: 0,
+            [REFRESH_UIAPI_KEY]: 0,
+            [SUPPORTED_KEY]: 0,
+            [UNSUPPORTED_KEY]: 0,
+        };
+        this.lastRefreshApiCall = null;
+    }
+    /**
+     * W-7801618
+     * Counter for occurrences where the incoming record to be merged has a different apiName.
+     * Dynamically generated metric, stored in an {@link RecordApiNameChangeCounters} object.
+     *
+     * @param context The transaction context.
+     *
+     * Note: Short-lived metric candidate, remove at the end of 230
+     */
+    incrementRecordApiNameChangeCount(_incomingApiName, existingApiName) {
+        let apiNameChangeCounter = this.recordApiNameChangeCounters[existingApiName];
+        if (apiNameChangeCounter === undefined) {
+            apiNameChangeCounter = counter(createMetricsKey(NAMESPACE, RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME, existingApiName));
+            this.recordApiNameChangeCounters[existingApiName] = apiNameChangeCounter;
+        }
+        apiNameChangeCounter.increment(1);
+    }
+    /**
+     * W-8620679
+     * Increment the counter for an UnfulfilledSnapshotError coming from luvio
+     *
+     * @param context The transaction context.
+     */
+    incrementAdapterRequestErrorCount(context) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        const adapterName = normalizeAdapterName(context.adapterName);
+        let adapterRequestErrorCounter = this.adapterUnfulfilledErrorCounters[adapterName];
+        if (adapterRequestErrorCounter === undefined) {
+            adapterRequestErrorCounter = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_ERROR_COUNT_METRIC_NAME, adapterName));
+            this.adapterUnfulfilledErrorCounters[adapterName] = adapterRequestErrorCounter;
+        }
+        adapterRequestErrorCounter.increment(1);
+        totalAdapterErrorMetric.increment(1);
+    }
+}
+function createMetricsKey(owner, name, unit) {
+    let metricName = name;
+    if (unit) {
+        metricName = metricName + '.' + unit;
+    }
+    return {
+        get() {
+            return { owner: owner, name: metricName };
+        },
+    };
+}
+/**
+ * Returns whether adapter is an Apex one or not.
+ * @param adapterName The name of the adapter.
+ */
+function isApexAdapter(adapterName) {
+    return adapterName.indexOf(APEX_ADAPTER_NAME) > -1;
+}
+/**
+ * Normalizes getApex adapter names to `Apex.getApex`. Non-Apex adapters will be prefixed with
+ * API family, if supplied. Example: `UiApi.getRecord`.
+ *
+ * Note: If you are adding additional logging that can come from getApex adapter contexts that provide
+ * the full getApex adapter name (i.e. getApex_[namespace]_[class]_[function]_[continuation]),
+ * ensure to call this method to normalize all logging to 'getApex'. This
+ * is because Argus has a 50k key cardinality limit. More context: W-8379680.
+ *
+ * @param adapterName The name of the adapter.
+ * @param apiFamily The API family of the adapter.
+ */
+function normalizeAdapterName(adapterName, apiFamily) {
+    if (isApexAdapter(adapterName)) {
+        return NORMALIZED_APEX_ADAPTER_NAME;
+    }
+    return apiFamily ? `${apiFamily}.${adapterName}` : adapterName;
+}
+const timerMetricTracker = create(null);
+/**
+ * Calls instrumentation/service telemetry timer
+ * @param name Name of the metric
+ * @param duration number to update backing percentile histogram, negative numbers ignored
+ */
+function updateTimerMetric(name, duration) {
+    let metric = timerMetricTracker[name];
+    if (metric === undefined) {
+        metric = timer(createMetricsKey(NAMESPACE, name));
+        timerMetricTracker[name] = metric;
+    }
+    timerMetricAddDuration(metric, duration);
+}
+function timerMetricAddDuration(timer, duration) {
+    // Guard against negative values since it causes error to be thrown by MetricsService
+    if (duration >= 0) {
+        timer.addDuration(duration);
+    }
+}
+/**
+ * W-10315098
+ * Increments the counter associated with the request response. Counts are bucketed by status.
+ */
+const requestResponseMetricTracker = create(null);
+function incrementRequestResponseCount(cb) {
+    const status = cb().status;
+    let metric = requestResponseMetricTracker[status];
+    if (metric === undefined) {
+        metric = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, NETWORK_ADAPTER_RESPONSE_METRIC_NAME, `${status.valueOf()}`));
+        requestResponseMetricTracker[status] = metric;
+    }
+    metric.increment();
+}
+/**
+ * Add a mark to the metrics service.
+ *
+ * @param name The mark name.
+ * @param content The mark content.
+ */
+function mark(name, content) {
+    mark$1(NAMESPACE, name, content);
+}
+/**
+ * Create a new instrumentation cache stats and return it.
+ *
+ * @param name The cache logger name.
+ */
+function registerLdsCacheStats(name) {
+    return registerCacheStats(`${NAMESPACE}:${name}`);
+}
+/**
+ * Add or overwrite hooks that require aura implementations
+ */
+function setAuraInstrumentationHooks() {
+    instrument({
+        recordConflictsResolved: (serverRequestCount) => {
+            // Ignore 0 values which can originate from ADS bridge
+            if (serverRequestCount > 0) {
+                updatePercentileHistogramMetric('record-conflicts-resolved', serverRequestCount);
+            }
+        },
+        nullDisplayValueConflict: ({ fieldType, areValuesEqual }) => {
+            const metricName = `merge-null-dv-count.${fieldType}`;
+            if (fieldType === 'scalar') {
+                incrementCounterMetric(`${metricName}.${areValuesEqual}`);
+            }
+            else {
+                incrementCounterMetric(metricName);
+            }
+        },
+        getRecordNotifyChangeAllowed: incrementGetRecordNotifyChangeAllowCount,
+        getRecordNotifyChangeDropped: incrementGetRecordNotifyChangeDropCount,
+        notifyRecordUpdateAvailableAllowed: incrementNotifyRecordUpdateAvailableAllowCount,
+        notifyRecordUpdateAvailableDropped: incrementNotifyRecordUpdateAvailableDropCount,
+        recordApiNameChanged: instrumentation.incrementRecordApiNameChangeCount.bind(instrumentation),
+        weakEtagZero: instrumentation.aggregateWeakETagEvents.bind(instrumentation),
+        getRecordNotifyChangeNetworkResult: instrumentation.notifyChangeNetwork.bind(instrumentation),
+    });
+    withRegistration('@salesforce/lds-adapters-uiapi', (reg) => setLdsAdaptersUiapiInstrumentation(reg));
+    instrument$1({
+        logCrud: logCRUDLightningInteraction,
+        networkResponse: incrementRequestResponseCount,
+    });
+    instrument$2({
+        refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
+        instrumentAdapter: instrumentation.instrumentAdapter.bind(instrumentation),
+    });
+    instrument$3({
+        timerMetricAddDuration: updateTimerMetric,
+    });
+    // Our getRecord through aggregate-ui CRUD logging has moved
+    // to lds-network-adapter. We still need to respect the
+    // orgs environment setting
+    if (forceRecordTransactionsDisabled === false) {
+        ldsNetworkAdapterInstrument({
+            getRecordAggregateResolve: (cb) => {
+                const { recordId, apiName } = cb();
+                logCRUDLightningInteraction('read', {
+                    recordId,
+                    recordType: apiName,
+                    state: 'SUCCESS',
+                });
+            },
+            getRecordAggregateReject: (cb) => {
+                const recordId = cb();
+                logCRUDLightningInteraction('read', {
+                    recordId,
+                    state: 'ERROR',
+                });
+            },
+        });
+    }
+    withRegistration('@salesforce/lds-network-adapter', (reg) => setLdsNetworkAdapterInstrumentation(reg));
+}
+/**
+ * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
+ *
+ * @param luvio The Luvio instance to instrument.
+ * @param store The InMemoryStore to instrument.
+ */
+function setupInstrumentation(luvio, store) {
+    setupInstrumentation$1(luvio, store);
+    setAuraInstrumentationHooks();
+}
+/**
+ * Note: locator.scope is set to 'force_record' in order for the instrumentation gate to work, which will
+ * disable all crud operations if it is on.
+ * @param eventSource - Source of the logging event.
+ * @param attributes - Free form object of attributes to log.
+ */
+function logCRUDLightningInteraction(eventSource, attributes) {
+    interaction(eventSource, 'force_record', null, eventSource, 'crud', attributes);
+}
+const instrumentation = new Instrumentation();
+
+const OBJECT_INFO_PREFIX = 'UiApi::ObjectInfoRepresentation:';
+const STORAGE_DROP_MARK_NAME = 'storage-drop';
+const STORAGE_DROP_MARK_CONTEXT = {
+    reason: 'Object info changed',
+};
+/**
+ * Watch a Luvio instance for metadata changes.
+ */
+function setupMetadataWatcher(luvio) {
+    // Watch for object info changes. Since we don't have enough information to understand to which
+    // extent an object info change may impact the application the only thing we do is to clear all
+    // the  persistent storages.
+    luvio.storeWatch(OBJECT_INFO_PREFIX, (entries) => {
+        for (let i = 0, len = entries.length; i < len; i++) {
+            const entry = entries[i];
+            const isObjectInfoUpdated = entry.inserted === false;
+            if (isObjectInfoUpdated) {
+                mark(STORAGE_DROP_MARK_NAME, STORAGE_DROP_MARK_CONTEXT);
+                clearStorages().catch(() => {
+                    /* noop */
+                });
+                break;
+            }
+        }
+    });
+}
+
+// This code *should* be in lds-network-adapter, but when combined with the Aura
+// component test workaround in lds-default-luvio it creates a circular dependecy
+// between lds-default-luvio and lds-network-adapter. We do the register on behalf
+// of lds-network-adapter here to avoid the cycle.
+register({
+    id: '@salesforce/lds-network-adapter',
+    instrument: ldsNetworkAdapterInstrument,
+});
+function setTrackedFieldsConfig(includeLeafNodeIdAndNameOnly) {
+    const depth = includeLeafNodeIdAndNameOnly ? 1 : 5;
+    configuration.setTrackedFieldLeafNodeIdAndNameOnly(includeLeafNodeIdAndNameOnly);
+    configuration.setTrackedFieldDepthOnCacheMiss(depth);
+    configuration.setTrackedFieldDepthOnCacheMergeConflict(depth);
+    configuration.setTrackedFieldDepthOnNotifyChange(depth);
+}
+function setupQueryEvaluators(luvio, store) {
+    const baseQueryEvaluator = new InMemoryStoreQueryEvaluator(store);
+    const recordRepresentationQueryEvaluator = new InMemoryRecordRepresentationQueryEvaluator(baseQueryEvaluator);
+    store.addStoreEventObserver({
+        onStorePublish: (event) => {
+            baseQueryEvaluator.registerKey(store, event.key, event.keySchema);
+        },
+    });
+    luvio.registerStoreQueryEvaluator(baseQueryEvaluator);
+    luvio.registerTypeQueryEvaluator(UiApiNamespace, RecordRepresentationRepresentationType, recordRepresentationQueryEvaluator);
+}
+// LDS initialization logic, invoked directly by Aura component tests
+function initializeLDS() {
+    const storeOptions = {
+        scheduler: () => { },
+    };
+    const store = new InMemoryStore(storeOptions);
+    const environment = new Environment(store, networkAdapter);
+    const luvio = new Luvio(environment, {
+        instrument: instrumentation.instrumentLuvio.bind(instrumentation),
+    });
+    setupInstrumentation(luvio, store);
+    setupMetadataWatcher(luvio);
+    setupQueryEvaluators(luvio, store);
+    setDefaultLuvio({ luvio });
+    setTrackedFieldsConfig(ldsTrackedFieldsBehaviorGate.isOpen({ fallback: false }));
+}
+// service function to be invoked by Aura
+function ldsEngineCreator() {
+    initializeLDS();
+    return { name: 'ldsEngineCreator' };
+}
+
+export { ldsEngineCreator as default, initializeLDS };
+// version: 1.100.2-ca56bb821

package/dist/main.d.ts

@@ -0,0 +1,5 @@
+export declare function initializeLDS(): void;
+declare function ldsEngineCreator(): {
+    name: string;
+};
+export default ldsEngineCreator;

package/dist/metadata.d.ts

@@ -0,0 +1,5 @@
+import type { Luvio } from '@luvio/engine';
+/**
+ * Watch a Luvio instance for metadata changes.
+ */
+export declare function setupMetadataWatcher(luvio: Luvio): void;

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@salesforce/lds-runtime-aura",
+    "version": "1.100.2",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "LDS engine for Aura runtime",
+    "main": "dist/ldsEngineCreator.js",
+    "module": "dist/ldsEngineCreator.js",
+    "types": "dist/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "import": "./dist/ldsEngineCreator.js",
+            "types": "./dist/main.d.ts",
+            "default": "./dist/ldsEngineCreator.js"
+        }
+    },
+    "sfdc": {
+        "path": "forcelds/ldsEngineCreator/",
+        "publishedFileName": "ldsEngineCreator.js",
+        "overrides": {
+            "artifactDirectory": "dist",
+            "outputModuleName": "ldsEngineCreator"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test:unit": "jest",
+        "test:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "test:size": "bundlesize",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
+    },
+    "devDependencies": {
+        "@salesforce/lds-adapters-uiapi": "^1.100.2",
+        "@salesforce/lds-ads-bridge": "^1.100.2",
+        "@salesforce/lds-aura-storage": "^1.100.2",
+        "@salesforce/lds-bindings": "^1.100.2",
+        "@salesforce/lds-instrumentation": "^1.100.2",
+        "@salesforce/lds-network-aura": "^1.100.2",
+        "@salesforce/lds-runtime-web": "^1.100.2"
+    },
+    "bundlesize": [
+        {
+            "path": "./dist/ldsEngineCreator.js",
+            "maxSize": "10 kB",
+            "compression": "brotli"
+        }
+    ]
+}