@salesforce/lds-runtime-one-runtime 1.457.0

package/dist/types/request-interceptors/csrf-token.d.ts

@@ -0,0 +1,19 @@
+import type { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResourceRequest } from '@luvio/engine';
+export declare const CSRF_TOKEN_HEADER = "X-CSRF-Token";
+/**
+ * Builds a request interceptor that adds CSRF token headers to mutating requests.
+ * The CSRF token is fetched once and cached for subsequent requests.
+ * Only POST, PUT, PATCH, and DELETE requests will have the CSRF token added.
+ *
+ * @returns A RequestInterceptor function for FetchParameters
+ */
+export declare function buildCsrfTokenInterceptor(): RequestInterceptor;
+/**
+ * Builds a Luvio request interceptor that adds CSRF token headers to mutating requests.
+ * The CSRF token is fetched once and cached for subsequent requests.
+ * Only POST, PUT, PATCH, and DELETE requests will have the CSRF token added.
+ *
+ * @returns A request interceptor function for Luvio ResourceRequest objects
+ */
+export declare function buildLuvioCsrfTokenInterceptor(): (resourceRequest: ResourceRequest) => Promise<ResourceRequest>;

package/dist/types/request-interceptors/entity-encoding.d.ts

@@ -0,0 +1,17 @@
+import type { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResourceRequest } from '@luvio/engine';
+export declare const ENTITY_ENCODING_HEADER = "X-Chatter-Entity-Encoding";
+export declare const ENTITY_ENCODING_DISABLED_VALUE = "false";
+/**
+ * Builds a request interceptor that sets `X-Chatter-Entity-Encoding: false` on
+ * outgoing requests. Connect REST applies HTML4 entity escaping to every string
+ * field of a response unless this header is sent with the literal value "false"
+ * (case-insensitive); any other value is equivalent to omitting the header.
+ */
+export declare function buildEntityEncodingInterceptor(): RequestInterceptor;
+/**
+ * Builds a Luvio request interceptor that sets `X-Chatter-Entity-Encoding: false`
+ * on the outgoing ResourceRequest when the header is absent. See
+ * {@link buildEntityEncodingInterceptor} for context.
+ */
+export declare function buildLuvioEntityEncodingInterceptor(): (resourceRequest: ResourceRequest) => PromiseLike<ResourceRequest>;

package/dist/types/request-interceptors/first-party-header.d.ts

@@ -0,0 +1,17 @@
+import { type RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResourceRequest } from '@luvio/engine';
+/**
+ * Builds a request interceptor that adds the LDS first party header to every
+ * outbound request.
+ *
+ * @returns A RequestInterceptor function for FetchParameters
+ */
+export declare function buildFirstPartyHeaderInterceptor(): RequestInterceptor;
+/**
+ * Builds a Luvio request interceptor that adds the LDS first party header to
+ * every outbound `ResourceRequest`. See {@link buildFirstPartyHeaderInterceptor} for
+ * the header semantics.
+ *
+ * @returns A request interceptor for Luvio ResourceRequest objects
+ */
+export declare function buildLuvioFirstPartyHeaderInterceptor(): (resourceRequest: ResourceRequest) => Promise<ResourceRequest>;

package/dist/types/request-interceptors/jwt-parameterization.d.ts

@@ -0,0 +1,50 @@
+import type { FetchParameters, RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+import { type JwtRequestModifier } from '@conduit-client/service-fetch-network/v1';
+import type { JwtManager } from '@conduit-client/jwt-manager';
+import type { ExtraInfo } from '../network-sfap';
+/**
+ * The context-seed key under which a custom command forwards its JWT mint
+ * parameters. The framework's `buildServiceDescriptor` merges the request init's
+ * `__contextSeed` onto the per-request interceptor context, so this interceptor
+ * reads the params off `context[JWT_MINT_PARAMS_SEED_KEY]`.
+ *
+ * This is a cross-team contract: the custom command writes this key, this
+ * interceptor reads it. It is intentionally an opaque key — OneStore does not
+ * define it and never inspects the param shape; the typed shape lives in the
+ * resolver.
+ */
+export declare const JWT_MINT_PARAMS_SEED_KEY = "jwtMintParams";
+/**
+ * Returns `true` if the fetch arguments already carry an `Authorization` header,
+ * across the three shapes the framework's `setHeader` handles: a `Request`
+ * resource's own headers, an `options.headers` `Headers` instance, or a plain
+ * record. The descriptor's guarded legacy interceptor uses this to skip when the
+ * parameterized interceptor has already authorized the request — avoiding a second
+ * mint and the throw `setHeaderAuthorization` raises on an existing header.
+ */
+export declare function hasAuthorizationHeader([resource, options]: FetchParameters): boolean;
+/**
+ * Builds the request interceptor that bridges the per-request context seed to the
+ * dispatching SFAP JwtManager for the **parameterized** mint path.
+ *
+ * For a parameterized SFAP command, the context carries `jwtMintParams`. This
+ * interceptor reads them, calls `jwtManager.getJwt(params)` (which the dispatching
+ * resolver routes to the parameterized resolver), attaches the `Authorization`
+ * header, and rewrites the request URL via the minted `baseUri`. The presence of
+ * that `Authorization` header is the signal the descriptor's guarded legacy
+ * interceptor uses to skip — so the legacy path does not mint a second time.
+ *
+ * For a legacy parameterless command the context carries no `jwtMintParams`, so
+ * this interceptor **early-returns on its first line** and the request flows
+ * unchanged to the legacy `buildJwtRequestHeaderInterceptor` — guaranteeing zero
+ * behavior change for non-opted-in adapters.
+ *
+ * Lives in `lds-lightning-platform` (not OneStore) beside the existing SFAP/CSRF
+ * interceptors, per the JWT-parameterization ADR §5: OneStore provides only the
+ * generic interceptor mechanism and the opaque context-seed channel; the service-
+ * specific bridge is a runtime-layer concern.
+ *
+ * @param jwtManager - the dispatching SFAP JwtManager
+ * @param jwtRequestModifier - applies the minted `extraInfo.baseUri` to the request URL
+ */
+export declare function buildJwtParameterizationInterceptor(jwtManager: JwtManager<unknown, ExtraInfo>, jwtRequestModifier?: JwtRequestModifier<ExtraInfo>): RequestInterceptor;

package/dist/types/request-interceptors/luvio-page-scoped-cache.d.ts

@@ -0,0 +1,11 @@
+import type { ResourceRequest } from '@luvio/engine';
+/**
+ * Builds a Luvio Request interceptor that adds page-scoped cache headers
+ * to ResourceRequest objects used by the Luvio network adapter.
+ *
+ * This interceptor works with the Luvio ResourceRequest format, which has
+ * a simpler structure than FetchParameters - headers are always a plain object.
+ *
+ * @returns A RequestInterceptor function for Luvio network requests
+ */
+export declare function buildLuvioPageScopedCacheRequestInterceptor(): (resourceRequest: ResourceRequest) => PromiseLike<ResourceRequest>;

package/dist/types/request-interceptors/luvio-third-party-tracker-register.d.ts

@@ -0,0 +1,2 @@
+import type { ResourceRequest } from '@luvio/engine';
+export declare function buildLuvioThirdPartyTrackerRegisterInterceptor(): (resourceRequest: ResourceRequest, context?: any) => PromiseLike<ResourceRequest>;

package/dist/types/request-interceptors/page-scoped-cache.d.ts

@@ -0,0 +1,2 @@
+import type { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+export declare function buildPageScopedCacheRequestInterceptor(): RequestInterceptor;

package/dist/types/request-interceptors/third-party-tracker-register.d.ts

@@ -0,0 +1,2 @@
+import type { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+export declare function buildThirdPartyTrackerRegisterInterceptor(): RequestInterceptor;

package/dist/types/request-interceptors/transport-send.d.ts

@@ -0,0 +1,5 @@
+import type { RequestInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResourceRequest } from '@luvio/engine';
+export declare const SFDC_REQUEST_ID_KEY = "X-SFDC-Request-Id";
+export declare function buildTransportMarksSendInterceptor(): RequestInterceptor;
+export declare function buildLuvioTransportMarksSendInterceptor(): (resourceRequest: ResourceRequest, context?: any) => PromiseLike<ResourceRequest>;

package/dist/types/response-interceptors/action-finish.d.ts

@@ -0,0 +1,4 @@
+import type { ResponseInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResponseInterceptor as LuvioResponseInterceptor } from '@salesforce/lds-network-fetch';
+export declare function buildActionMarksReceiveInterceptor(): ResponseInterceptor;
+export declare function buildLuvioActionMarksReceiveInterceptor(): LuvioResponseInterceptor;

package/dist/types/response-interceptors/error-body-normalization.d.ts

@@ -0,0 +1,20 @@
+import type { ResponseInterceptor as LuvioResponseInterceptor } from '@salesforce/lds-network-fetch';
+/**
+ * Normalizes Connect REST error envelopes into the Aura Shape A
+ * (ConnectInJava) shape, so consumers can read `response.body.errorCode`
+ * regardless of transport.
+ *
+ * - HTTP error envelope (this path): `[{ errorCode, message }, ...]`
+ * - Aura Shape A: `{ errorCode, message, statusCode, ... }`
+ *
+ * The full array is preserved at `body.enhancedErrorInfo.allErrors` since
+ * Connect can return multiple errors per response.
+ *
+ * Aura Shape B (`{ error: "..." }`) is an Aura-only fallback that never
+ * appears on the HTTP path, so no normalization is needed for it here.
+ *
+ * Ordering: must run AFTER any other interceptor that inspects the raw
+ * error body shape (e.g. the 5xx interceptor's ErrorId extraction reads
+ * `body[0].message` from the array form).
+ */
+export declare function buildLuvioErrorBodyNormalizationInterceptor(): LuvioResponseInterceptor;

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

@@ -0,0 +1,19 @@
+import type { LoggerService } from '@conduit-client/utils';
+import type { ResponseInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResponseInterceptor as LuvioResponseInterceptor } from '@salesforce/lds-network-fetch';
+export type LexRuntimeError = {
+    message: string;
+    severity: string;
+    name: string;
+    stack: string | null;
+    handled: boolean;
+    reported: boolean;
+    id: number;
+};
+export type LexErrorEventArgs = {
+    message: string;
+    error: string | null;
+    auraError: LexRuntimeError;
+};
+export declare function buildLexRuntime5xxStatusResponseInterceptor(logger: LoggerService): ResponseInterceptor;
+export declare function buildLexRuntimeLuvio5xxStatusResponseInterceptor(): LuvioResponseInterceptor;

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

@@ -0,0 +1,5 @@
+import type { LoggerService } from '@conduit-client/utils';
+import type { ResponseInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResponseInterceptor as LuvioResponseInterceptor } from '@salesforce/lds-network-fetch';
+export declare function buildLexRuntimeSessionExpirationResponseInterceptor(logger: LoggerService): ResponseInterceptor;
+export declare function buildLexRuntimeLuvioSessionExpirationResponseInterceptor(): LuvioResponseInterceptor;

package/dist/types/response-interceptors/transport-receive.d.ts

@@ -0,0 +1,4 @@
+import type { ResponseInterceptor } from '@conduit-client/service-fetch-network/v1';
+import type { ResponseInterceptor as LuvioResponseInterceptor } from '@salesforce/lds-network-fetch';
+export declare function buildTransportMarksReceiveInterceptor(): ResponseInterceptor;
+export declare function buildLuvioTransportMarksReceiveInterceptor(): LuvioResponseInterceptor;

package/dist/types/retry-interceptors/csrf-retry.d.ts

@@ -0,0 +1,2 @@
+import type { RetryInterceptor } from '@conduit-client/service-fetch-network/v1';
+export declare function buildCsrfRetryInterceptor(): RetryInterceptor;

package/dist/types/retry-interceptors/luvio-fetch-retry.d.ts

@@ -0,0 +1,8 @@
+import type { LuvioRetryInterceptor } from '@salesforce/lds-network-fetch';
+/**
+ * Builds the LuvioRetryInterceptor used by the UIAPI fetch adapter.
+ *
+ * A fresh RetryService and policy instances are created per request to keep the
+ * CSRF policy's mutableRequest context isolated from concurrent requests.
+ */
+export declare function buildLuvioFetchRetryInterceptor(): LuvioRetryInterceptor;

package/dist/types/retry-policies/csrf-token-retry-policy.d.ts

@@ -0,0 +1,72 @@
+import type { RetryContext } from '@conduit-client/service-retry/v1';
+import { RetryPolicy } from '@conduit-client/service-retry/v1';
+import type { FetchParameters } from '@conduit-client/service-fetch-network/v1';
+type CsrfTokenRetryPolicyConfig = {
+    /**
+     * Maximum number of retry attempts for CSRF token refresh.
+     * Typically should be 1 since we only want to retry once after refreshing.
+     */
+    maxRetries: number;
+};
+/**
+ * Mutable container for fetch arguments that can be modified between retries.
+ */
+export interface MutableFetchRequest {
+    args: FetchParameters;
+}
+/**
+ * Retry policy that handles CSRF token expiration errors.
+ *
+ * When a request fails with a CSRF token error this policy will:
+ * 1. Detect the error condition in shouldRetry
+ * 2. Refresh the CSRF token in prepareRetry hook
+ * 3. Update the request headers with the new token via mutable context
+ * 4. Retry the request once (maxRetries = 1)
+ *
+ */
+export declare class CsrfTokenRetryPolicy extends RetryPolicy<Response> {
+    private config;
+    private requestContext?;
+    constructor(config?: CsrfTokenRetryPolicyConfig);
+    /**
+     * Allows the fetch service to pass mutable request context.
+     * This is a side-channel that enables request modification between retries.
+     *
+     * @param context - Mutable container holding fetch arguments
+     */
+    setRequestContext(context: MutableFetchRequest): void;
+    /**
+     * Determines if a failed request should be retried due to CSRF token issues.
+     */
+    shouldRetry(result: Response, context: RetryContext<Response>): Promise<boolean>;
+    /**
+     * CSRF token refresh should happen immediately with no delay.
+     */
+    calculateDelay(_result: Response, _context: RetryContext<Response>): Promise<number>;
+    /**
+     * Called by retry service before each retry attempt.
+     *
+     * This hook is supported by the Conduit retry service (with prepareRetry support).
+     * It performs token refresh and request update:
+     * 1. Refreshes the CSRF token from the server
+     * 2. Updates the mutable request context with the new token
+     *
+     * Note: We already validated this is a CSRF error in shouldRetry,
+     * so we can proceed directly to token refresh.
+     *
+     * The fetch service must call setRequestContext() to provide the mutable args container.
+     * When the retry service re-executes the operation, it will use the updated args.
+     *
+     * @param _result - The failed response that triggered the retry (unused, already validated)
+     * @param _context - Current retry context (unused but part of interface)
+     */
+    prepareRetry(_result: Response, _context: RetryContext<Response>): Promise<void>;
+}
+/**
+ * Helper to check if a response indicates a CSRF token error.
+ *
+ * @param response - The response to check
+ * @returns true if the response indicates a CSRF token error (INVALID_ACCESS_TOKEN)
+ */
+export declare function isCsrfError(response: Response): Promise<boolean>;
+export {};

package/dist/types/retry-policies/fetch-throttling-retry-policy.d.ts

@@ -0,0 +1,18 @@
+import type { RetryContext } from '@conduit-client/service-retry/v1';
+import { RetryPolicy } from '@conduit-client/service-retry/v1';
+type FetchThrottlingRetryPolicyConfig = {
+    maxRetries: number;
+    maxTimeToRetry: number;
+    baseDelay: number;
+    maxDelay: number;
+    exponentialFactor: number;
+    jitterPercent: number;
+};
+export declare class FetchThrottlingRetryPolicy extends RetryPolicy<Response> {
+    private config;
+    constructor(config?: FetchThrottlingRetryPolicyConfig);
+    shouldRetry(result: Response, context: RetryContext<Response>): Promise<boolean>;
+    calculateDelay(result: Response, context: RetryContext<Response>): Promise<number>;
+    parseRetryAfterHeader(result: Response): number | undefined;
+}
+export {};

package/dist/types/retry-policies/luvio-csrf-token-retry-policy.d.ts

@@ -0,0 +1,31 @@
+import type { RetryContext } from '@conduit-client/service-retry/v1';
+import { RetryPolicy } from '@conduit-client/service-retry/v1';
+import type { FetchResponse, ResourceRequest } from '@luvio/engine';
+type LuvioCsrfTokenRetryPolicyConfig = {
+    maxRetries: number;
+};
+/**
+ * Mutable container for the ResourceRequest that can be updated between retries.
+ */
+export interface MutableLuvioRequest {
+    request: ResourceRequest;
+}
+export declare class LuvioCsrfTokenRetryPolicy extends RetryPolicy<FetchResponse<any>> {
+    private config;
+    private requestContext?;
+    constructor(config?: LuvioCsrfTokenRetryPolicyConfig);
+    setRequestContext(context: MutableLuvioRequest): void;
+    shouldRetry(result: FetchResponse<any>, context: RetryContext<FetchResponse<any>>): Promise<boolean>;
+    calculateDelay(_result: FetchResponse<any>, _context: RetryContext<FetchResponse<any>>): Promise<number>;
+    prepareRetry(_result: FetchResponse<any>, _context: RetryContext<FetchResponse<any>>): Promise<void>;
+}
+/**
+ * Returns true when a Luvio FetchResponse indicates a CSRF token error.
+ * Body is already parsed JSON on FetchResponse, so no clone/json() needed.
+ *
+ * UIAPI error bodies come in both shapes: an object `{ errorCode, message }`
+ * for single errors, or an array `[{ errorCode, message }]` for endpoints that
+ * return collections of errors. Handle both.
+ */
+export declare function isCsrfError(response: FetchResponse<any>): boolean;
+export {};

package/dist/types/retry-policies/luvio-fetch-throttling-retry-policy.d.ts

@@ -0,0 +1,18 @@
+import { RetryPolicy, type RetryContext } from '@conduit-client/service-retry/v1';
+import type { FetchResponse } from '@luvio/engine';
+type LuvioFetchThrottlingRetryPolicyConfig = {
+    maxRetries: number;
+    maxTimeToRetry: number;
+    baseDelay: number;
+    maxDelay: number;
+    exponentialFactor: number;
+    jitterPercent: number;
+};
+export declare class LuvioFetchThrottlingRetryPolicy extends RetryPolicy<FetchResponse<any>> {
+    private config;
+    constructor(config?: LuvioFetchThrottlingRetryPolicyConfig);
+    shouldRetry(result: FetchResponse<any>, context: RetryContext<FetchResponse<any>>): Promise<boolean>;
+    calculateDelay(result: FetchResponse<any>, context: RetryContext<FetchResponse<any>>): Promise<number>;
+    parseRetryAfterHeader(result: FetchResponse<any>): number | undefined;
+}
+export {};

package/dist/types/service-variants/durable-cache-inclusion-policy.d.ts

@@ -0,0 +1,82 @@
+import { type StorageConfig } from '@salesforce/lds-durable-storage';
+import { type CacheInclusionPolicyServiceDescriptor, type CacheQuery, type CacheUpdate, DurableCacheInclusionPolicy } from '@conduit-client/service-cache-inclusion-policy/v1';
+import type { Cache, CacheEntry, Key } from '@conduit-client/service-cache/v1';
+import type { DeepReadonly } from '@conduit-client/utils';
+/**
+ * Configuration options for AuraDurableCacheInclusionPolicy
+ */
+export type DurableCacheConfig = Partial<StorageConfig>;
+/**
+ * Durable cache inclusion policy that uses AuraStorage for persistent L2 cache
+ */
+export declare class AuraDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
+    private readonly storage;
+    constructor(config?: DurableCacheConfig);
+    /**
+     * Revive cache entries from AuraStorage into L1 cache
+     * @param keys - Set of keys to revive
+     * @param l1 - L1 cache instance
+     * @returns Set of keys that were successfully revived
+     */
+    revive(keys: Set<Key>, l1: Cache): Promise<Set<Key>>;
+    /**
+     * Sync changed keys from L1 cache to AuraStorage (L2 cache)
+     * @param changedKeys - Set of keys that have changed
+     * @param l1 - L1 cache instance
+     */
+    syncToL2Cache(changedKeys: Set<Key>, l1: Cache): Promise<void>;
+    /**
+     * Find entries matching a query
+     * @param query - Cache query to match entries
+     */
+    find(query: CacheQuery): AsyncGenerator<[key: Key, value: DeepReadonly<CacheEntry<unknown>>], void, unknown>;
+    /**
+     * Find and modify entries matching a query
+     * @param query - Cache query to match entries
+     * @param cacheUpdate - Update to apply to matching entries
+     *
+     * Note: This method does not publish cache events. Callers should publish
+     * appropriate cache events (e.g., 'cacheEviction') after eviction operations
+     * to notify subscribers.
+     */
+    findAndModify(query: CacheQuery, cacheUpdate: CacheUpdate): AsyncGenerator<Key, void, unknown>;
+    /**
+     * Check if an entry matches a cache query
+     * @param key - Cache key to check
+     * @param entry - Cache entry to check
+     * @param query - Query to match against
+     * @returns true if the entry matches the query
+     */
+    private matchesQuery;
+    private isAndQuery;
+    private isOrQuery;
+    private isNotQuery;
+    private matchesKey;
+    private matchesMetadata;
+    /**
+     * Apply an update to a cache entry
+     * @param entry - Original cache entry
+     * @param update - Update to apply
+     * @returns Object indicating the result: modified entry, deleted marker, or no-op
+     */
+    private applyUpdate;
+    /**
+     * Build an update for a cache entry
+     * @param update - The cache update operation to apply
+     * @param existing - The existing cache entry being modified
+     * @returns An object indicating the type of update
+     */
+    private buildUpdate;
+    /**
+     * Build an invalidated cache control metadata
+     * @param existingCacheControl - The current CacheControlMetadata
+     * @returns A new CacheControlMetadata object with maxAge set to 0, or undefined if no changes needed
+     */
+    private buildInvalidatedCacheControl;
+}
+/**
+ * Factory function to create an AuraDurableCacheInclusionPolicy service descriptor
+ * @param config - Optional configuration for the storage
+ * @returns Service descriptor for the cache inclusion policy
+ */
+export declare function buildAuraDurableCacheInclusionPolicyService(config?: DurableCacheConfig): CacheInclusionPolicyServiceDescriptor;

package/dist/types/sfap-jwt-mint-params.d.ts

@@ -0,0 +1,80 @@
+import type { JwtMintParams } from '@conduit-client/jwt-manager';
+/**
+ * JSON-primitive value a dynamic mint parameter may take.
+ *
+ * Mirrors the SFAP Lightning JWT Service's own `validateValue`
+ * (`SFAPLightningJwtServiceResource.java`), which accepts native `Boolean`,
+ * `Number`, or `String` and lets the minted claim's type follow the JSON type.
+ * The resolver therefore forwards these primitives verbatim — it must NOT
+ * stringify booleans/numbers, because the `data_cloud_user_claims` handler gates
+ * on native `Boolean.TRUE.equals(...)` and silently drops a stringified `"true"`.
+ */
+export type SfapDynamicParamValue = string | boolean | number;
+/**
+ * Typed shape of the params the SFAP Lightning JWT Service understands.
+ * Lives in the resolver layer because OneStore is param-shape-agnostic; it
+ * sees only an opaque `JwtMintParams` bag and stable-JSON-stringifies it for
+ * cache keying.
+ */
+export type SfapJwtMintParams = {
+    scopes?: string[];
+    dynamicParams?: Record<string, SfapDynamicParamValue>;
+};
+/**
+ * The `extraInfo` the SFAP JWT resolver returns alongside the minted token: the
+ * per-tenant base URI the downstream SFAP API request is rewritten to.
+ */
+export type ParameterizedSfapExtraInfo = {
+    baseUri: string;
+};
+type DynamicParameterItem = {
+    name: string;
+    value: SfapDynamicParamValue;
+};
+/**
+ * The SFAP Lightning JWT Service mint request body. Sent as the `requestBody`
+ * named param of the `postSFAPLightningJwtService` Aura controller method.
+ * Matches the server's `SFAPLightningJwtServiceInputRepresentation`: `scopes` is
+ * a single space-delimited string; `dynamicParameters` is `{ items: [{ name, value }] }`.
+ */
+export type SfapJwtRequestBody = {
+    scopes?: string;
+    dynamicParameters?: {
+        items: DynamicParameterItem[];
+    };
+};
+/**
+ * Normalize SFAP-shaped params into the opaque `JwtMintParams` bag that callers
+ * hand to `JwtManager.getJwt(params)`. Scopes are sorted because they are
+ * semantically a set — without this, `['a', 'b']` and `['b', 'a']` would cache
+ * as separate entries (OneStore treats arrays as ordered under stable-JSON
+ * serialization; see ADR "JWT Parameterization" §2).
+ *
+ * MANDATORY CONSUMER ENTRY POINT. Every consumer that mints a parameterized
+ * SFAP JWT MUST assemble its params through this function before calling the
+ * manager. The cache key is derived by `JwtManager` from the caller's params
+ * (`cacheKeyFor(params)`) *before* the resolver runs — so the resolver cannot
+ * normalize after the fact. Set-stable caching therefore depends on the caller
+ * routing params through here. Do NOT sort inside the resolver: that would only
+ * reorder the wire body, not the cache key, and mutating the caller's params
+ * mid-call would desync the in-flight-dedup key from the stored-token key.
+ */
+export declare function buildSfapJwtMintParams(params: SfapJwtMintParams): JwtMintParams;
+export type SfapParamsResult = {
+    params: SfapJwtMintParams;
+} | {
+    error: string;
+};
+/**
+ * Validate and narrow an opaque `JwtMintParams` bag to the SFAP-shaped subset the
+ * resolver forwards. Returns `{ error }` (surfaced as a resolver rejection) for a
+ * malformed bag rather than throwing.
+ */
+export declare function coerceToSfapParams(params: JwtMintParams): SfapParamsResult;
+/**
+ * Build the SFAP mint request body from the coerced params: `scopes` joined into a
+ * single space-delimited string, `dynamicParams` mapped to `dynamicParameters.items`.
+ * Empty scopes / dynamic params are omitted.
+ */
+export declare function buildRequestBody(params: SfapJwtMintParams): SfapJwtRequestBody;
+export {};

package/package.json

@@ -0,0 +1,98 @@
+{
+    "name": "@salesforce/lds-runtime-one-runtime",
+    "version": "1.457.0",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "LDS engine for the LEX on One Runtime (LWR) runtime.",
+    "main": "dist/oneRuntimeLdsEngineCreator.js",
+    "module": "dist/oneRuntimeLdsEngineCreator.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/main.d.ts",
+            "import": "./dist/oneRuntimeLdsEngineCreator.js",
+            "default": "./dist/oneRuntimeLdsEngineCreator.js"
+        }
+    },
+    "sfdc": {
+        "path": "forcelds/oneRuntimeLdsEngineCreator/",
+        "publishedFileName": "oneRuntimeLdsEngineCreator.js",
+        "overrides": {
+            "artifactDirectory": "dist",
+            "outputModuleName": "oneRuntimeLdsEngineCreator"
+        }
+    },
+    "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-one-runtime"
+    },
+    "devDependencies": {
+        "@conduit-client/service-provisioner": "3.27.0",
+        "@conduit-client/tools-core": "3.27.0",
+        "@salesforce/lds-adapters-apex": "^1.457.0",
+        "@salesforce/lds-adapters-uiapi": "^1.457.0",
+        "@salesforce/lds-ads-bridge": "^1.457.0",
+        "@salesforce/lds-aura-storage": "^1.457.0",
+        "@salesforce/lds-bindings": "^1.457.0",
+        "@salesforce/lds-instrumentation": "^1.457.0",
+        "@salesforce/lds-network-adapter": "^1.457.0",
+        "@salesforce/lds-network-aura": "^1.457.0",
+        "@salesforce/lds-network-fetch": "^1.457.0",
+        "jwt-encode": "1.0.1"
+    },
+    "dependencies": {
+        "@conduit-client/command-aura-graphql-normalized-cache-control": "3.27.0",
+        "@conduit-client/command-aura-network": "3.27.0",
+        "@conduit-client/command-aura-normalized-cache-control": "3.27.0",
+        "@conduit-client/command-fetch-network": "3.27.0",
+        "@conduit-client/command-http-graphql-normalized-cache-control": "3.27.0",
+        "@conduit-client/command-http-normalized-cache-control": "3.27.0",
+        "@conduit-client/command-ndjson": "3.27.0",
+        "@conduit-client/command-network": "3.27.0",
+        "@conduit-client/command-sse": "3.27.0",
+        "@conduit-client/command-streaming": "3.27.0",
+        "@conduit-client/jwt-manager": "3.27.0",
+        "@conduit-client/service-aura-network": "3.27.0",
+        "@conduit-client/service-bindings-imperative": "3.27.0",
+        "@conduit-client/service-bindings-lwc": "3.27.0",
+        "@conduit-client/service-cache": "3.27.0",
+        "@conduit-client/service-cache-control": "3.27.0",
+        "@conduit-client/service-cache-inclusion-policy": "3.27.0",
+        "@conduit-client/service-config": "3.27.0",
+        "@conduit-client/service-feature-flags": "3.27.0",
+        "@conduit-client/service-fetch-network": "3.27.0",
+        "@conduit-client/service-instrument-command": "3.27.0",
+        "@conduit-client/service-pubsub": "3.27.0",
+        "@conduit-client/service-renewable-resource-manager": "3.27.0",
+        "@conduit-client/service-store": "3.27.0",
+        "@conduit-client/utils": "3.27.0",
+        "@luvio/network-adapter-composable": "0.161.2",
+        "@luvio/network-adapter-fetch": "0.161.2",
+        "@lwc/state": "^0.29.0",
+        "@salesforce/lds-adapters-onestore-graphql": "^1.457.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.415.0",
+        "@salesforce/lds-durable-storage": "^1.457.0",
+        "@salesforce/lds-luvio-service": "^1.457.0",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.457.0"
+    },
+    "luvioBundlesize": [
+        {
+            "path": "./dist/oneRuntimeLdsEngineCreator.js",
+            "maxSize": {
+                "none": "416 kB",
+                "min": "190 kB",
+                "compressed": "73 kB"
+            }
+        }
+    ],
+    "volta": {
+        "extends": "../../package.json"
+    }
+}