@salesforce/lds-runtime-aura 1.463.0 → 1.465.0

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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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/transport-receive.d.ts

@@ -1,4 +0,0 @@
-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/luvio-fetch-retry.d.ts

@@ -1,11 +0,0 @@
-import type { LuvioRetryInterceptor } from '@salesforce/lds-network-fetch';
-/**
- * Builds the LuvioRetryInterceptor used by the UIAPI fetch adapter. A fresh
- * RetryService and policies are created per request to keep the
- * mutableRequest context isolated across concurrent requests.
- *
- * Policy order matters: ComposedRetryPolicy uses the first matching policy's
- * shouldRetry/delay. A keyed-write 503 fails throttling's method gate, so it
- * falls to the idempotency policy to replay same-key.
- */
-export declare function buildLuvioFetchRetryInterceptor(): LuvioRetryInterceptor;

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

@@ -1,72 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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;
-    private method?;
-    private operationType?;
-    constructor(config?: FetchThrottlingRetryPolicyConfig, method?: string | undefined, operationType?: string | undefined);
-    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

@@ -1,24 +0,0 @@
-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>;
-}
-/** True when a Luvio FetchResponse indicates a CSRF token error. */
-export declare function isCsrfError(response: FetchResponse<any>): boolean;
-export {};

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

@@ -1,19 +0,0 @@
-import { RetryPolicy, type RetryContext } from '@conduit-client/service-retry/v1';
-import type { FetchResponse, ResourceRequest } 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;
-    private request?;
-    constructor(config?: LuvioFetchThrottlingRetryPolicyConfig, request?: ResourceRequest | undefined);
-    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/retry-policies/luvio-idempotency-retry-policy.d.ts

@@ -1,29 +0,0 @@
-import type { RetryContext } from '@conduit-client/service-retry/v1';
-import { RetryPolicy } from '@conduit-client/service-retry/v1';
-import type { FetchResponse } from '@luvio/engine';
-import type { MutableLuvioRequest } from './luvio-csrf-token-retry-policy';
-type LuvioIdempotencyRetryPolicyConfig = {
-    maxRetries: number;
-};
-/**
- * Retry policy for writes carrying an `Idempotency-Key`. A peer of the CSRF and
- * throttling policies in the composed retry chain, not a modification of
- * either: its 503 (keyed-write lock-acquire) and throttling's 503 (keyless
- * GET/read-POST) never contend because they key off different requests, and it
- * only claims a 400/409 when the body carries an idempotency-specific
- * errorCode, so it never steals CSRF's INVALID_ACCESS_TOKEN.
- *
- * Eligibility follows from the header's *presence* on the request, not from
- * the mint interceptor's registry flag — so a stale flag can never cause an
- * unsafe replay.
- */
-export declare class LuvioIdempotencyRetryPolicy extends RetryPolicy<FetchResponse<any>> {
-    private config;
-    private requestContext?;
-    constructor(config?: LuvioIdempotencyRetryPolicyConfig);
-    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>;
-}
-export {};

package/dist/types/retry-policies/unconfigured-retry-policy.d.ts

@@ -1,20 +0,0 @@
-import type { RetryContext } from '@conduit-client/service-retry/v1';
-import { RetryPolicy } from '@conduit-client/service-retry/v1';
-/**
- * The default policy for the runtime's shared retry service.
- *
- * Every fetch-service descriptor wired with the retry service also supplies its
- * own `retry:` interceptor, which passes a per-request policy as the override to
- * `applyRetry` — so this default is never consulted on any real path. It is
- * reachable only if a descriptor is registered with the retry service but omits
- * its `retry:` interceptor; in that case service-fetch-network falls back to
- * `retryService.applyRetry(fetch)` with no override, and this policy runs.
- *
- * That is a wiring mistake, not a runtime condition. We surface it loudly in
- * development rather than silently degrading to never-retry (the behavior of a
- * plain empty policy), following the repo convention for should-never-run paths.
- */
-export declare class UnconfiguredRetryPolicy extends RetryPolicy<Response> {
-    shouldRetry(_result: Response, _context: RetryContext<Response>): Promise<boolean>;
-    calculateDelay(_result: Response, _context: RetryContext<Response>): Promise<number>;
-}

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

@@ -1,82 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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 {};