@salesforce/lds-runtime-aura 0.1.0-dev1

package/dist/types/predictive-loading/request-strategy/get-related-list-info-request-strategy.d.ts

@@ -0,0 +1,50 @@
+import type { BaseAdapterRequest } from './request-strategy';
+import type { GetRelatedListInfoConfig } from '@salesforce/lds-adapters-uiapi';
+import type { RequestEntry } from '../common';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRelatedListInfoRequest = {
+    adapterName: 'getRelatedListInfo';
+    config: GetRelatedListInfoConfig;
+};
+type GetRelatedListInfoContext = {
+    objectApiName: string;
+    recordTypeId: string;
+};
+export declare const GET_RELATED_LIST_INFO_ADAPTER_NAME = "getRelatedListInfo";
+export declare class GetRelatedListInfoRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListInfoConfig, GetRelatedListInfoRequest, GetRelatedListInfoContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRelatedListInfoConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/RelatedListInfoRepresentation").RelatedListInfoRepresentation>;
+    /**
+     * @override
+     */
+    isContextDependent(context: GetRelatedListInfoContext, request: GetRelatedListInfoRequest): boolean;
+    /**
+     * @override
+     */
+    buildConcreteRequest(similarRequest: GetRelatedListInfoRequest, _context: GetRelatedListInfoContext): GetRelatedListInfoRequest;
+    /**
+     * @override
+     */
+    transformForSave(request: GetRelatedListInfoRequest): GetRelatedListInfoRequest;
+    /**
+     * For performance reasons (fear of over-fetching), we only want to predict single requests which either are not
+     * part of a batch request OR specify optional parameters (thus requiring data differing from that of a batch
+     * request).
+     *
+     * ADG currently handles the batching of getRelatedListInfo -> getRelatedListInfoBatch
+     * https://gitcore.soma.salesforce.com/core-2206/core-public/blob/p4/main/core/ui-laf-components/modules/laf/batchingPortable/reducers/RelatedListInfoBatchReducer.js
+     *
+     * @param unfilteredRequests
+     * @returns GetRelatedListInfoRequest[]
+     * @override
+     */
+    reduce(unfilteredRequests: RequestEntry<BaseAdapterRequest<unknown>>[]): RequestEntry<GetRelatedListInfoRequest>[];
+    /**
+     * Return true if the request config doesn't specify values for any of the optional parameters.
+     *
+     * @param config
+     * @param ignoreRecordType
+     */
+    isRequiredOnlyConfig(config: GetRelatedListInfoConfig, ignoreRecordType?: boolean): boolean;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-related-list-records-batch-request-strategy.d.ts

@@ -0,0 +1,32 @@
+import type { GetRelatedListRecordsBatchConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRelatedListRecordsBatchRequest = {
+    adapterName: 'getRelatedListRecordsBatch';
+    config: GetRelatedListRecordsBatchConfig;
+};
+type GetRelatedListRecordsBatchContext = {
+    recordId: string;
+};
+export declare const GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME = "getRelatedListRecordsBatch";
+export declare class GetRelatedListRecordsBatchRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListRecordsBatchConfig, GetRelatedListRecordsBatchRequest, GetRelatedListRecordsBatchContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRelatedListRecordsBatchConfig, import("@salesforce/lds-adapters-uiapi").RelatedListRecordCollectionBatchRepresentation>;
+    buildConcreteRequest(similarRequest: GetRelatedListRecordsBatchRequest, context: GetRelatedListRecordsBatchContext): GetRelatedListRecordsBatchRequest;
+    transformForSaveSimilarRequest(request: GetRelatedListRecordsBatchRequest): GetRelatedListRecordsBatchRequest;
+    isContextDependent(context: GetRelatedListRecordsBatchContext, request: GetRelatedListRecordsBatchRequest): boolean;
+    /**
+     * Can combine two seperate batch requests if the parentRecordId is the same.
+     * @param reqA The first GetRelatedListRecordsBatchConfig.
+     * @param reqB The first GetRelatedListRecordsBatchConfig.
+     * @returns true if the requests can be combined, otherwise false.
+     */
+    canCombine(reqA: GetRelatedListRecordsBatchConfig, reqB: GetRelatedListRecordsBatchConfig): boolean;
+    /**
+     * Merge the relatedListParameters together between two combinable batch requests.
+     * @param reqA The first GetRelatedListRecordsBatchConfig.
+     * @param reqB The first GetRelatedListRecordsBatchConfig.
+     * @returns The combined request.
+     */
+    combineRequests(reqA: GetRelatedListRecordsBatchConfig, reqB: GetRelatedListRecordsBatchConfig): GetRelatedListRecordsBatchConfig;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-related-list-records-request-strategy.d.ts

@@ -0,0 +1,34 @@
+import type { GetRelatedListRecordsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { RequestEntry } from '../common';
+import type { BaseAdapterRequest } from './request-strategy';
+export type GetRelatedListRecordsRequest = {
+    adapterName: 'getRelatedListRecords';
+    config: GetRelatedListRecordsConfig;
+};
+type GetRelatedListRecordsContext = {
+    recordId: string;
+};
+export declare const GET_RELATED_LIST_RECORDS_ADAPTER_NAME = "getRelatedListRecords";
+export declare class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListRecordsConfig, GetRelatedListRecordsRequest, GetRelatedListRecordsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRelatedListRecordsConfig, import("@salesforce/lds-adapters-uiapi").RelatedListRecordCollectionRepresentation>;
+    buildConcreteRequest(similarRequest: GetRelatedListRecordsRequest, context: GetRelatedListRecordsContext): GetRelatedListRecordsRequest;
+    /**
+     *
+     * This method returns GetRelatedListRecordsRequest[] that won't be part of a batch request.
+     *
+     * ADG currently handles the batching of GetRelatedListRecords -> GetRelatedListRecordsBatch
+     * https://gitcore.soma.salesforce.com/core-2206/core-public/blob/p4/main/core/ui-laf-components/modules/laf/batchingPortable/reducers/RelatedListRecordsBatchReducer.js
+     *
+     * For performance reasons (fear to overfetch), we only check that the Single relatedListId is not present in any of the Batch requests,
+     * but we don't check for any other parameters.
+     *
+     * @param unfilteredRequests All of the request available for predictions.
+     * @returns GetRelatedListRecordsRequest[] That should be a prediction.
+     */
+    reduce(unfilteredRequests: RequestEntry<BaseAdapterRequest<unknown>>[]): RequestEntry<GetRelatedListRecordsRequest>[];
+    transformForSaveSimilarRequest(request: GetRelatedListRecordsRequest): GetRelatedListRecordsRequest;
+    isContextDependent(context: GetRelatedListRecordsContext, request: GetRelatedListRecordsRequest): boolean;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-related-lists-actions-request-strategy.d.ts

@@ -0,0 +1,28 @@
+import type { GetRelatedListsActionsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRelatedListsActionsRequest = {
+    adapterName: 'getRelatedListsActions';
+    config: GetRelatedListsActionsConfig;
+};
+type GetRelatedListsActionsContext = {
+    recordId: string;
+};
+export declare const GET_RELATED_LISTS_ACTIONS_ADAPTER_NAME = "getRelatedListsActions";
+export declare class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListsActionsConfig, GetRelatedListsActionsRequest, GetRelatedListsActionsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRelatedListsActionsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ActionRelatedListsCollectionBatchRepresentation").ActionRelatedListsCollectionBatchRepresentation>;
+    buildConcreteRequest(similarRequest: GetRelatedListsActionsRequest, context: GetRelatedListsActionsContext): GetRelatedListsActionsRequest;
+    transformForSaveSimilarRequest(request: GetRelatedListsActionsRequest): GetRelatedListsActionsRequest;
+    isContextDependent(context: GetRelatedListsActionsContext, request: GetRelatedListsActionsRequest): boolean;
+    /**
+     * Can only reduce two requests when they have the same recordId, and
+     * the individual relatedListAction config only have relatedListId.
+     *
+     * @param reqA
+     * @param reqB
+     * @returns boolean
+     */
+    canCombine(reqA: GetRelatedListsActionsConfig, reqB: GetRelatedListsActionsConfig): boolean;
+    combineRequests(reqA: GetRelatedListsActionsConfig, reqB: GetRelatedListsActionsConfig): GetRelatedListsActionsConfig;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/get-related-lists-info-strategy.d.ts

@@ -0,0 +1,30 @@
+import type { GetRelatedListsInfoConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+export type GetRelatedListsInfoRequest = {
+    adapterName: 'getRelatedListsInfo';
+    config: GetRelatedListsInfoConfig;
+};
+type GetRelatedListsInfoContext = {
+    objectApiName: string;
+    recordTypeId: string;
+};
+export declare const GET_RELATED_LISTS_INFO_ADAPTER_NAME = "getRelatedListsInfo";
+export declare class GetRelatedListsInfoRequestStrategy extends LuvioAdapterRequestStrategy<GetRelatedListsInfoConfig, GetRelatedListsInfoRequest, GetRelatedListsInfoContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRelatedListsInfoConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/RelatedListSummaryInfoCollectionRepresentation").RelatedListSummaryInfoCollectionRepresentation>;
+    /**
+     * @override
+     */
+    isContextDependent(context: GetRelatedListsInfoContext, request: GetRelatedListsInfoRequest): boolean;
+    /**
+     * @override
+     */
+    buildConcreteRequest(similarRequest: GetRelatedListsInfoRequest, _context: GetRelatedListsInfoContext): GetRelatedListsInfoRequest;
+    /**
+     * @override
+     */
+    transformForSave(request: GetRelatedListsInfoRequest): GetRelatedListsInfoRequest;
+    canCombine(reqA: GetRelatedListsInfoConfig, reqB: GetRelatedListsInfoConfig): boolean;
+    combineRequests(reqA: GetRelatedListsInfoConfig, _reqB: GetRelatedListsInfoConfig): GetRelatedListsInfoConfig;
+}
+export {};

package/dist/types/predictive-loading/request-strategy/index.d.ts

@@ -0,0 +1,21 @@
+export * from './get-components-request-strategy';
+export * from './get-record-avatars-request-strategy';
+export * from './get-record-request-strategy';
+export * from './get-records-request-strategy';
+export * from './get-record-actions-request-strategy';
+export * from './get-object-info-request-strategy';
+export * from './get-object-infos-request-strategy';
+export * from './get-related-lists-actions-request-strategy';
+export * from './get-related-list-info-request-strategy';
+export * from './get-related-list-info-batch-request-strategy';
+export * from './get-related-list-records-request-strategy';
+export * from './get-related-list-records-batch-request-strategy';
+export * from './get-apex-request-strategy';
+export * from './get-list-info-by-name-request-strategy';
+export * from './luvio-adapter-request-strategy';
+export * from './request-strategy';
+export * from './get-list-infos-by-object-name-request-strategy';
+export * from './get-list-records-by-name-request-strategy';
+export * from './get-list-object-info-request-strategy';
+export * from './get-related-lists-info-strategy';
+export * from './get-related-list-actions-request-strategy';

package/dist/types/predictive-loading/request-strategy/lex-request-strategy.d.ts

@@ -0,0 +1,13 @@
+import { RequestStrategy } from './request-strategy';
+import type { LexContext, LexRequest, LexRequestOptions } from '../lex';
+import type { DefaultPageContext } from '../pages';
+export declare abstract class LexRequestStrategy<Config = unknown, Request extends LexRequest<Config> = LexRequest<Config>, Context extends LexContext = DefaultPageContext> extends RequestStrategy<Config, Request, Context, LexRequestOptions> {
+    /**
+     * Whether or not requests from this strategies can be boxcarred by Aura.
+     * If they are, the lex prefetcher will run predictions of this strategy with a limit,
+     * to avoid predictions being boxcared.
+     *
+     * @returns boolean
+     */
+    get isBoxcarable(): boolean;
+}

package/dist/types/predictive-loading/request-strategy/luvio-adapter-request-strategy.d.ts

@@ -0,0 +1,27 @@
+import type { AdapterFactory, Luvio, Snapshot } from '@luvio/engine';
+import { LexRequestStrategy } from './lex-request-strategy';
+import type { LexContext, LexRequest, LexRequestOptions } from '../lex';
+export declare const DEFAULT_RESOURCE_CONTEXT: {
+    sourceContext: {
+        tagName: string;
+        actionConfig: {
+            background: boolean;
+            hotspot: boolean;
+            longRunning: boolean;
+        };
+    };
+};
+export declare abstract class LuvioAdapterRequestStrategy<AdapterConfig, Request extends LexRequest<AdapterConfig>, Context extends LexContext> extends LexRequestStrategy<AdapterConfig, Request, Context> {
+    private luvio;
+    constructor(luvio: Luvio);
+    /**
+     * Name of the adapter used in this strategy.
+     */
+    abstract adapterName: string;
+    /**
+     * Factory for the adapter used in this strategy.
+     */
+    abstract adapterFactory: AdapterFactory<AdapterConfig, any>;
+    execute(config: AdapterConfig, options?: LexRequestOptions): Snapshot<any> | Promise<Snapshot<any>> | null;
+    protected createAdapterContext(options: LexRequestOptions): any;
+}

package/dist/types/predictive-loading/request-strategy/request-strategy.d.ts

@@ -0,0 +1,79 @@
+import type { RequestEntry } from '../common';
+export type BaseAdapterRequest<Config = unknown> = {
+    adapterName: string;
+    config: Config;
+};
+export declare const enum RequestPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
+export declare enum PdlRequestPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
+export declare abstract class RequestStrategy<Config, Request extends BaseAdapterRequest<Config>, Context, Options extends Record<string, any>> {
+    /**
+     * Name of the adapter used in this strategy.
+     */
+    abstract adapterName: string;
+    abstract execute(config: Config, options?: Options): any;
+    abstract buildConcreteRequest(similarRequest: Request, context: Context): Request;
+    getRequestPriority(_request: Request, _context: Context): RequestPriority;
+    /**
+     * Perform any transformations required to prepare the request for saving.
+     *
+     * e.g. If the request is for a record, we move all fields in the fields array
+     * into the optionalFields array
+     *
+     * @param request - The request to transform
+     * @returns
+     */
+    transformForSave(request: Request, _context?: Context): Request;
+    /**
+     * Transforms the request for saving similar requests
+     * @param request Request to transform for saving similar requests
+     * @returns Transformed request
+     */
+    transformForSaveSimilarRequest(request: Request, _context?: Context): Request;
+    /**
+     * Filter requests to only those that are for this strategy.
+     *
+     * @param unfilteredRequests array of requests to filter
+     * @returns
+     */
+    protected filterRequests(unfilteredRequests: RequestEntry<any>[]): RequestEntry<Request>[];
+    /**
+     * Reduce requests by combining those based on a strategies implementations
+     * of canCombine and combineRequests.
+     * @param unfilteredRequests array of requests to filter
+     * @returns
+     */
+    reduce(unfilteredRequests: RequestEntry<any>[]): RequestEntry<Request>[];
+    /**
+     * Check if two requests can be combined.
+     *
+     * By default, requests are not combinable.
+     * @param reqA config of request A
+     * @param reqB config of request B
+     * @returns
+     */
+    canCombine(_reqA: Config, _reqB: Config): boolean;
+    /**
+     * Takes two request configs and combines them into a single request config.
+     *
+     * @param reqA config of request A
+     * @param reqB config of request B
+     * @returns
+     */
+    combineRequests(reqA: Config, _reqB: Config): Config;
+    /**
+     * Checks adapter config against request context to determine if the request is context dependent.
+     *
+     * By default, requests are not context dependent.
+     * @param request
+     * @returns
+     */
+    isContextDependent(_context: Context, _request: Request): boolean;
+}

package/dist/types/predictive-loading/request-strategy-manager/request-strategy-manager.d.ts

@@ -0,0 +1,12 @@
+import type { LexRequestStrategy } from '../request-strategy/lex-request-strategy';
+export declare class RequestStrategyManager {
+    private requestStrategies;
+    private requestStrategiesByAdapterName;
+    constructor(requestStrategies?: LexRequestStrategy[]);
+    private setRequestStrategy;
+    private deleteRequestStrategy;
+    register(requestStrategies: LexRequestStrategy[]): boolean[];
+    unregister(requestStrategies: LexRequestStrategy[]): boolean[];
+    get(adapterName: string): LexRequestStrategy<unknown, import("../lex").LexRequest<unknown>, import("..").DefaultPageContext> | undefined;
+    getAll(): LexRequestStrategy<unknown, import("../lex").LexRequest<unknown>, import("..").DefaultPageContext>[];
+}

package/dist/types/predictive-loading/storage/aura-prefetch-storage.d.ts

@@ -0,0 +1,25 @@
+import { type PrefetchStorage } from '.';
+import { InMemoryPrefetchStorage } from './in-memory-prefetch-storage';
+import { type AuraStorage, type AuraStorageConfig } from '@salesforce/lds-aura-storage';
+export declare const DEFAULT_STORAGE_OPTIONS: {
+    name: string;
+    persistent: boolean;
+    secure: boolean;
+    maxSize: number;
+    expiration: number;
+    clearOnInit: boolean;
+    debugLogging: boolean;
+    version: number;
+};
+export type StorageOptions = Partial<AuraStorageConfig> & {
+    onPredictionsReadyCallback?: () => void;
+};
+export declare function buildAuraPrefetchStorage(options?: StorageOptions): PrefetchStorage;
+export declare function buildAuraLocalStoragePrefetchStorage(options?: StorageOptions): PrefetchStorage;
+export declare class AuraPrefetchStorage implements PrefetchStorage {
+    private auraStorage;
+    private inMemoryStorage;
+    constructor(auraStorage: AuraStorage, inMemoryStorage: InMemoryPrefetchStorage, onPredictionsReadyCallback?: () => void);
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): T | undefined;
+}

package/dist/types/predictive-loading/storage/in-memory-prefetch-storage.d.ts

@@ -0,0 +1,6 @@
+import type { PrefetchStorage } from '.';
+export declare class InMemoryPrefetchStorage implements PrefetchStorage {
+    data: Record<string, any>;
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): T | undefined;
+}

package/dist/types/predictive-loading/storage/index.d.ts

@@ -0,0 +1,8 @@
+import { StorageOptions } from './aura-prefetch-storage';
+export type PrefetchStorage = {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): Promise<void>;
+};
+export declare function buildPrefetchStorage(useLocalStorage: boolean, options: StorageOptions): PrefetchStorage;
+export * from './in-memory-prefetch-storage';
+export * from './local-prefetch-storage';

package/dist/types/predictive-loading/storage/local-prefetch-storage.d.ts

@@ -0,0 +1,7 @@
+import type { PrefetchStorage } from '.';
+export declare class LocalPrefetchStorage implements PrefetchStorage {
+    private localStorage;
+    constructor(localStorage: typeof window.localStorage);
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): T | undefined;
+}

package/dist/types/response-interceptors/lex-runtime-5xx-status.d.ts

@@ -0,0 +1,16 @@
+import { LoggerService } from '@luvio/utils';
+import { ResponseInterceptor } from '@luvio/service-fetch-network/v1';
+export type LexRuntimeError = {
+    message: string;
+    severity: string;
+    name: string;
+    stack: string | null;
+    handled: boolean;
+    reported: boolean;
+};
+export type LexErrorEventArgs = {
+    message: string;
+    error: string | null;
+    auraError: LexRuntimeError;
+};
+export declare function buildLexRuntime5xxStatusResponseInterceptor(logger: LoggerService): ResponseInterceptor;

package/dist/types/response-interceptors/lex-runtime-auth-expiration-redirect.d.ts

@@ -0,0 +1,3 @@
+import { LoggerService } from '@luvio/utils';
+import { ResponseInterceptor } from '@luvio/service-fetch-network/v1';
+export declare function buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger: LoggerService): ResponseInterceptor;

package/package.json

@@ -0,0 +1,92 @@
+{
+    "name": "@salesforce/lds-runtime-aura",
+    "version": "0.1.0-dev1",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "LDS engine for Aura runtime",
+    "main": "dist/ldsEngineCreator.js",
+    "module": "dist/ldsEngineCreator.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/main.d.ts",
+            "import": "./dist/ldsEngineCreator.js",
+            "default": "./dist/ldsEngineCreator.js"
+        }
+    },
+    "sfdc": {
+        "path": "forcelds/ldsEngineCreator/",
+        "publishedFileName": "ldsEngineCreator.js",
+        "overrides": {
+            "artifactDirectory": "dist",
+            "outputModuleName": "ldsEngineCreator"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test:unit": "jest",
+        "test:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "test:size": "luvioBundlesize",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
+    },
+    "devDependencies": {
+        "@luvio/service-provisioner": "5.61.0",
+        "@luvio/tools-core": "5.61.0",
+        "@salesforce/lds-adapters-apex": "^0.1.0-dev1",
+        "@salesforce/lds-adapters-uiapi": "^0.1.0-dev1",
+        "@salesforce/lds-ads-bridge": "^0.1.0-dev1",
+        "@salesforce/lds-aura-storage": "^0.1.0-dev1",
+        "@salesforce/lds-bindings": "^0.1.0-dev1",
+        "@salesforce/lds-instrumentation": "^0.1.0-dev1",
+        "@salesforce/lds-network-aura": "^0.1.0-dev1",
+        "@salesforce/lds-network-fetch": "^0.1.0-dev1",
+        "jwt-encode": "1.0.1"
+    },
+    "dependencies": {
+        "@luvio/command-aura-graphql-normalized-cache-control": "5.61.0",
+        "@luvio/command-aura-network": "5.61.0",
+        "@luvio/command-aura-normalized-cache-control": "5.61.0",
+        "@luvio/command-aura-resource-cache-control": "5.61.0",
+        "@luvio/command-fetch-network": "5.61.0",
+        "@luvio/command-http-graphql-normalized-cache-control": "5.61.0",
+        "@luvio/command-http-normalized-cache-control": "5.61.0",
+        "@luvio/command-ndjson": "5.61.0",
+        "@luvio/command-network": "5.61.0",
+        "@luvio/command-sse": "5.61.0",
+        "@luvio/command-streaming": "5.61.0",
+        "@luvio/network-adapter-composable": "0.158.7",
+        "@luvio/network-adapter-fetch": "0.158.7",
+        "@luvio/service-aura-network": "5.61.0",
+        "@luvio/service-cache": "5.61.0",
+        "@luvio/service-cache-control": "5.61.0",
+        "@luvio/service-cache-inclusion-policy": "5.61.0",
+        "@luvio/service-feature-flags": "5.61.0",
+        "@luvio/service-fetch-network": "5.61.0",
+        "@luvio/service-instrument-command": "5.61.0",
+        "@luvio/service-pubsub": "5.61.0",
+        "@luvio/service-store": "5.61.0",
+        "@luvio/utils": "5.61.0",
+        "@lwc/state": "^0.23.0",
+        "@salesforce/lds-adapters-onestore-graphql": "^0.1.0-dev1",
+        "@salesforce/lds-adapters-uiapi-lex": "^0.1.0-dev1",
+        "@salesforce/lds-luvio-service": "^0.1.0-dev1",
+        "@salesforce/lds-luvio-uiapi-records-service": "^0.1.0-dev1"
+    },
+    "luvioBundlesize": [
+        {
+            "path": "./dist/ldsEngineCreator.js",
+            "maxSize": {
+                "none": "350 kB",
+                "min": "190 kB",
+                "compressed": "50 kB"
+            }
+        }
+    ],
+    "volta": {
+        "extends": "../../package.json"
+    }
+}