@salesforce/sdk-core 1.131.1 → 1.131.3

package/dist/index.d.ts

@@ -13,7 +13,8 @@ export type { LightningSDK, LMSMessage, LMSSubscription, MessageChannel } from '
 export type { OpenAISDK, SalesforceACCSDK } from './platforms';
 export type { JsonRpcBase, JsonRpcRequest, JsonRpcError, JsonRpcSuccessResponse, JsonRpcErrorResponse, JsonRpcResponse, JsonRpcNotification, JsonRpcMessage, JsonRpcPendingRequest, JsonRpcPendingRequestMap, } from './jsonrpc';
 export { isJsonRpcBase, isJsonRpcSuccessResponse, isJsonRpcErrorResponse, isJsonRpcResponse, isJsonRpcNotification, isJsonRpcRequest, } from './jsonrpc';
-export { JsonRpcClient } from './jsonrpc-client';
+export { JsonRpcClient, WindowPostMessageTransport } from './jsonrpc-client';
+export type { Transport } from './jsonrpc-client';
 export { McpAppsSession } from './mcpapps-session';
 export type { McpAppsHostContext, McpAppsSessionOptions } from './mcpapps-session';
 export { getSurfaceCapabilities } from './capabilities';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGhD,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGvF,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C,YAAY,EACX,WAAW,EACX,UAAU,EACV,WAAW,EACX,OAAO,EACP,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,cAAc,EACd,QAAQ,EACR,SAAS,GACT,MAAM,QAAQ,CAAC;AAGhB,YAAY,EACX,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,SAAS,EACT,OAAO,GACP,MAAM,QAAQ,CAAC;AAGhB,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAGvE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7F,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/D,YAAY,EACX,WAAW,EACX,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,wBAAwB,GACxB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACN,aAAa,EACb,wBAAwB,EACxB,sBAAsB,EACtB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,GAChB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAGnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGhD,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGvF,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C,YAAY,EACX,WAAW,EACX,UAAU,EACV,WAAW,EACX,OAAO,EACP,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,cAAc,EACd,QAAQ,EACR,SAAS,GACT,MAAM,QAAQ,CAAC;AAGhB,YAAY,EACX,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,SAAS,EACT,OAAO,GACP,MAAM,QAAQ,CAAC;AAGhB,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAGvE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7F,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/D,YAAY,EACX,WAAW,EACX,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,wBAAwB,GACxB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACN,aAAa,EACb,wBAAwB,EACxB,sBAAsB,EACtB,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,GAChB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAC7E,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAGnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -1,4 +1,4 @@
-var r = /* @__PURE__ */ ((e) => (e.WebApp = "WebApp", e.MicroFrontend = "Micro-Frontend", e.OpenAI = "OpenAI", e.SalesforceACC = "Salesforce-ACC", e.MCPApps = "MCP-Apps", e.Mosaic = "Mosaic", e))(r || {});
+var i = /* @__PURE__ */ ((e) => (e.WebApp = "WebApp", e.MicroFrontend = "Micro-Frontend", e.OpenAI = "OpenAI", e.SalesforceACC = "Salesforce-ACC", e.MCPApps = "MCP-Apps", e.Mosaic = "Mosaic", e))(i || {});
 const d = f();
 function f() {
   if (typeof window > "u")
@@ -32,15 +32,44 @@ function h(e) {
 function g(e) {
   return l(e) && "method" in e && typeof e.method == "string" && !("id" in e);
 }
-function P(e) {
+function b(e) {
   return l(e) && "id" in e && typeof e.id == "number" && "method" in e && typeof e.method == "string";
 }
 class T {
+  targetOrigin;
+  /**
+   * @param targetOrigin - origin passed as the second argument to
+   *   `window.parent.postMessage`. Defaults to `"*"` for backwards
+   *   compatibility. Pin to the known parent origin when possible to
+   *   prevent leaking messages to a cross-origin navigated parent.
+   */
+  constructor(t = "*") {
+    this.targetOrigin = t;
+  }
+  post(t) {
+    window.parent?.postMessage(t, this.targetOrigin);
+  }
+  onMessage(t) {
+    const s = (n) => {
+      t(n.data);
+    };
+    return window.addEventListener("message", s), () => window.removeEventListener("message", s);
+  }
+}
+class M {
   nextRequestId = 1;
   pending = /* @__PURE__ */ new Map();
   notificationHandlers = /* @__PURE__ */ new Map();
-  constructor() {
-    window.addEventListener("message", this.onMessage);
+  transport;
+  /**
+   * Construct a JSON-RPC client bound to the given transport.
+   *
+   * @param transport - the transport to use; defaults to a
+   *   `WindowPostMessageTransport`, which preserves the original
+   *   `window.parent.postMessage` behaviour.
+   */
+  constructor(t = new T()) {
+    this.transport = t, this.transport.onMessage(this.onMessage);
   }
   /**
    * Register a handler for a specific JSON-RPC notification method
@@ -49,7 +78,7 @@ class T {
    * When a notification with the registered method is received, the handler
    * will be invoked with the notification params.
    *
-   * @param method - The notification method to handle (e.g., "ui/notifications/host-context-changed")
+   * @param method - The notification method to handle (e.g. "ui/notifications/host-context-changed")
    * @param handler - Callback function to process the notification params
    *
    * @example
@@ -57,29 +86,31 @@ class T {
    *   this.handleHostContextChanged(params);
    * });
    */
-  registerNotificationHandler(s, t) {
-    this.notificationHandlers.has(s) || this.notificationHandlers.set(s, /* @__PURE__ */ new Set()), this.notificationHandlers.get(s).add(t);
+  registerNotificationHandler(t, s) {
+    this.notificationHandlers.has(t) || this.notificationHandlers.set(t, /* @__PURE__ */ new Set()), this.notificationHandlers.get(t).add(s);
   }
   /**
-   * Handle incoming JSON-RPC messages from parent window
-   * Processes both responses (for requests) and notifications
+   * Handle inbound JSON-RPC messages from the transport.
+   *
+   * Processes both responses (for requests) and notifications. Non-JSON-RPC
+   * payloads are silently ignored so that a shared transport can be used for
+   * multiple protocols without cross-talk.
    */
-  onMessage = (s) => {
-    const t = s.data;
+  onMessage = (t) => {
     if (h(t)) {
-      const n = this.pending.get(t.id);
-      if (!n)
+      const s = this.pending.get(t.id);
+      if (!s)
         return;
-      this.pending.delete(t.id), u(t) ? n.reject(new Error(t.error.message || "Request failed")) : n.resolve(t.result);
+      this.pending.delete(t.id), u(t) ? s.reject(new Error(t.error.message || "Request failed")) : s.resolve(t.result);
       return;
     }
     if (g(t)) {
-      const n = this.notificationHandlers.get(t.method);
-      n && n.forEach((o) => o(t.params));
+      const s = this.notificationHandlers.get(t.method);
+      s && s.forEach((n) => n(t.params));
     }
   };
   /**
-   * Send a JSON-RPC request to the parent window
+   * Send a JSON-RPC request to the peer.
    *
    * @param method - The JSON-RPC method name
    * @param params - The method parameters
@@ -91,22 +122,22 @@ class T {
    *   content: { type: "text", text: "Hello" }
    * });
    */
-  request(s, t) {
-    const n = this.nextRequestId++, o = {
+  request(t, s) {
+    const n = this.nextRequestId++, r = {
       jsonrpc: "2.0",
       id: n,
-      method: s,
-      params: t
+      method: t,
+      params: s
     };
-    return new Promise((i, c) => {
+    return new Promise((o, c) => {
       this.pending.set(n, {
-        resolve: i,
+        resolve: o,
         reject: c
-      }), window.parent?.postMessage(o, "*");
+      }), this.transport.post(r);
     });
   }
   /**
-   * Send a JSON-RPC notification to the parent window
+   * Send a JSON-RPC notification to the peer.
    *
    * Notifications are one-way messages that do not expect a response.
    * Use notifications for:
@@ -128,17 +159,17 @@ class T {
    *   height: 600
    * });
    */
-  sendNotification(s, t) {
+  sendNotification(t, s) {
     const n = {
       jsonrpc: "2.0",
-      method: s,
-      params: t
+      method: t,
+      params: s
     };
-    window.parent?.postMessage(n, "*");
+    this.transport.post(n);
   }
 }
-const M = 500, C = "2026-01-26";
-class a extends T {
+const C = 500, w = "2026-01-26";
+class a extends M {
   static initPromise = null;
   hostCtx = {};
   _handshakeSucceeded = !1;
@@ -148,10 +179,10 @@ class a extends T {
    * The first call performs the SEP-1865 handshake. Concurrent and subsequent
    * calls reuse the same session and handshake result.
    */
-  static async getInstance(s) {
+  static async getInstance(t) {
     return a.initPromise || (a.initPromise = (async () => {
-      const t = new a();
-      return await t.handshake(s), t;
+      const s = new a();
+      return await s.handshake(t), s;
     })()), a.initPromise;
   }
   /**
@@ -168,18 +199,18 @@ class a extends T {
    * On timeout or error, falls back to an empty host context so the app can
    * still render (graceful degradation for non-SEP-1865 hosts).
    */
-  async handshake(s) {
-    const t = s?.handshakeTimeoutMs ?? M, n = s?.appInfo ?? { name: "mcp-app", version: "1.0.0" };
+  async handshake(t) {
+    const s = t?.handshakeTimeoutMs ?? C, n = t?.appInfo ?? { name: "mcp-app", version: "1.0.0" };
     try {
-      const o = /* @__PURE__ */ Symbol("timeout"), i = await Promise.race([
+      const r = /* @__PURE__ */ Symbol("timeout"), o = await Promise.race([
         this.request("ui/initialize", {
-          protocolVersion: C,
+          protocolVersion: w,
           appInfo: n,
           appCapabilities: {}
         }),
-        new Promise((c) => setTimeout(() => c(o), t))
+        new Promise((c) => setTimeout(() => c(r), s))
       ]);
-      i !== o && (this.hostCtx = i.hostContext ?? {}, this._handshakeSucceeded = !0, this.registerNotificationHandler("ui/notifications/host-context-changed", (c) => {
+      o !== r && (this.hostCtx = o.hostContext ?? {}, this._handshakeSucceeded = !0, this.registerNotificationHandler("ui/notifications/host-context-changed", (c) => {
         this.hostCtx = {
           ...this.hostCtx,
           ...c
@@ -199,17 +230,17 @@ class a extends T {
   // ── Public wrappers ──────────────────────────────────────────────────
   // Widen access from protected to public so SDK classes can use the
   // shared transport without extending JsonRpcClient themselves.
-  request(s, t) {
-    return super.request(s, t);
+  request(t, s) {
+    return super.request(t, s);
   }
-  sendNotification(s, t) {
-    super.sendNotification(s, t);
+  sendNotification(t, s) {
+    super.sendNotification(t, s);
   }
-  registerNotificationHandler(s, t) {
-    super.registerNotificationHandler(s, t);
+  registerNotificationHandler(t, s) {
+    super.registerNotificationHandler(t, s);
   }
 }
-const y = {
+const m = {
   callTool: !0,
   sendMessageToHost: !0,
   readResource: !0,
@@ -229,7 +260,7 @@ const y = {
   // TODO
   getTheme: !0,
   resize: !0
-}, w = {
+}, y = {
   callTool: !0,
   sendMessageToHost: !0,
   readResource: !1,
@@ -248,7 +279,7 @@ const y = {
   displayModal: !0,
   getTheme: !0,
   resize: !1
-}, m = {
+}, A = {
   callTool: !1,
   sendMessageToHost: !0,
   readResource: !1,
@@ -267,7 +298,7 @@ const y = {
   displayModal: !1,
   getTheme: !0,
   resize: !1
-}, A = {
+}, I = {
   callTool: !1,
   sendMessageToHost: !1,
   readResource: !1,
@@ -287,47 +318,48 @@ const y = {
   getTheme: !1,
   resize: !1
 };
-function b(e) {
+function R(e) {
   switch (e) {
-    case r.MCPApps:
-      return { ...y };
-    case r.OpenAI:
-      return { ...w };
-    case r.SalesforceACC:
+    case i.MCPApps:
       return { ...m };
-    case r.Mosaic:
-    case r.WebApp:
-    case r.MicroFrontend:
-    default:
+    case i.OpenAI:
+      return { ...y };
+    case i.SalesforceACC:
       return { ...A };
+    case i.Mosaic:
+    case i.WebApp:
+    case i.MicroFrontend:
+    default:
+      return { ...I };
   }
 }
-const I = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
-function R(e, s) {
+const P = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
+function H(e, t) {
   return new Proxy(e, {
-    get(t, n, o) {
-      if (typeof n == "symbol" || I.has(n)) {
-        const i = Reflect.get(t, n, o);
-        return typeof i == "function" ? i.bind(t) : i;
+    get(s, n, r) {
+      if (typeof n == "symbol" || P.has(n)) {
+        const o = Reflect.get(s, n, r);
+        return typeof o == "function" ? o.bind(s) : o;
       }
       throw new TypeError(
-        `\`${s}()\` returns a Promise — did you forget to await it?
-Use \`const sdk = await ${s}();\` before accessing SDK methods.`
+        `\`${t}()\` returns a Promise — did you forget to await it?
+Use \`const sdk = await ${t}();\` before accessing SDK methods.`
       );
     }
   });
 }
 export {
-  T as JsonRpcClient,
+  M as JsonRpcClient,
   a as McpAppsSession,
-  r as Surface,
+  i as Surface,
+  T as WindowPostMessageTransport,
   S as getSurface,
-  b as getSurfaceCapabilities,
+  R as getSurfaceCapabilities,
   l as isJsonRpcBase,
   u as isJsonRpcErrorResponse,
   g as isJsonRpcNotification,
-  P as isJsonRpcRequest,
+  b as isJsonRpcRequest,
   h as isJsonRpcResponse,
   p as isJsonRpcSuccessResponse,
-  R as wrapSDKPromise
+  H as wrapSDKPromise
 };

package/dist/jsonrpc-client.d.ts

@@ -1,11 +1,76 @@
 /**
- * Base class for JSON-RPC 2.0 clients using postMessage
+ * Abstract transport for a JSON-RPC 2.0 client.
  *
- * This class provides core JSON-RPC client functionality for MCP Apps implementations.
- * It handles request/response correlation, message validation, and error handling.
+ * A `Transport` is a bidirectional, structured-message pipe. The `JsonRpcClient`
+ * uses it to send JSON-RPC messages (`post`) and subscribe to inbound ones
+ * (`onMessage`). The transport itself is agnostic to the JSON-RPC framing —
+ * it simply moves `unknown` payloads between two endpoints.
+ *
+ * This abstraction exists so `JsonRpcClient` can be driven by either the
+ * `window.parent.postMessage` channel (default, preserved for existing MCP
+ * Apps iframes) or a `MessagePort`-backed transport (used by newer
+ * microfrontend containers that receive a dedicated channel during
+ * bootstrap).
+ */
+export interface Transport {
+    /**
+     * Deliver a single structured message to the peer. Implementations MUST NOT
+     * throw on transient conditions (a closed port, a missing parent window,
+     * etc.) — drop the message silently instead, matching the prior
+     * `window.parent?.postMessage` behaviour.
+     */
+    post(message: unknown): void;
+    /**
+     * Subscribe to inbound structured messages from the peer. The callback
+     * receives the already-unwrapped message payload (never a `MessageEvent`).
+     *
+     * @returns an unsubscribe function that removes this listener.
+     */
+    onMessage(callback: (message: unknown) => void): () => void;
+}
+/**
+ * Default `Transport` backing the JSON-RPC client in an iframe context.
+ *
+ * Outbound messages go to `window.parent` via `postMessage(msg, targetOrigin)`,
+ * and inbound messages come from `window.addEventListener("message", ...)`
+ * with only the `event.data` payload forwarded to subscribers.
+ *
+ * The `targetOrigin` passed to `postMessage` is configurable and defaults to
+ * `"*"` to preserve the pre-refactor wire behaviour. Callers embedding the
+ * iframe should pin this to the expected parent origin when it is known, so
+ * that messages cannot leak to a parent that has been navigated to a
+ * different origin since the iframe loaded.
+ *
+ * Missing `window.parent` (e.g. top-level document) is tolerated: `post` is a
+ * no-op, matching the prior optional-chaining behaviour.
+ */
+export declare class WindowPostMessageTransport implements Transport {
+    private readonly targetOrigin;
+    /**
+     * @param targetOrigin - origin passed as the second argument to
+     *   `window.parent.postMessage`. Defaults to `"*"` for backwards
+     *   compatibility. Pin to the known parent origin when possible to
+     *   prevent leaking messages to a cross-origin navigated parent.
+     */
+    constructor(targetOrigin?: string);
+    post(message: unknown): void;
+    onMessage(callback: (message: unknown) => void): () => void;
+}
+/**
+ * Base class for JSON-RPC 2.0 clients.
+ *
+ * This class provides core JSON-RPC client functionality for MCP Apps and
+ * sf-mfe implementations. It handles request/response correlation, message
+ * validation, and error handling.
+ *
+ * The transport layer is pluggable via the `Transport` interface. By default
+ * the client uses `WindowPostMessageTransport`, which preserves the original
+ * `window.parent.postMessage` wire behaviour. Callers can inject a different
+ * transport (e.g. a `MessageChannelTransport`) without changing any of the
+ * request/response semantics below.
  *
  * Subclasses should extend this class and use the protected `request()` method
- * to send JSON-RPC requests to the parent window.
+ * to send JSON-RPC requests to the peer.
  *
  * @example
  * export class MCPAppsViewSDK extends JsonRpcClient implements ViewSDK {
@@ -16,12 +81,26 @@
  *     });
  *   }
  * }
+ *
+ * @example
+ * // Injecting a custom transport (e.g. for a MessageChannel-based flow).
+ * class MyClient extends JsonRpcClient {
+ *   constructor(transport: Transport) { super(transport); }
+ * }
  */
 export declare class JsonRpcClient {
     private nextRequestId;
     private pending;
     private notificationHandlers;
-    constructor();
+    private readonly transport;
+    /**
+     * Construct a JSON-RPC client bound to the given transport.
+     *
+     * @param transport - the transport to use; defaults to a
+     *   `WindowPostMessageTransport`, which preserves the original
+     *   `window.parent.postMessage` behaviour.
+     */
+    constructor(transport?: Transport);
     /**
      * Register a handler for a specific JSON-RPC notification method
      *
@@ -29,7 +108,7 @@ export declare class JsonRpcClient {
      * When a notification with the registered method is received, the handler
      * will be invoked with the notification params.
      *
-     * @param method - The notification method to handle (e.g., "ui/notifications/host-context-changed")
+     * @param method - The notification method to handle (e.g. "ui/notifications/host-context-changed")
      * @param handler - Callback function to process the notification params
      *
      * @example
@@ -39,12 +118,15 @@ export declare class JsonRpcClient {
      */
     protected registerNotificationHandler(method: string, handler: (params: unknown) => void): void;
     /**
-     * Handle incoming JSON-RPC messages from parent window
-     * Processes both responses (for requests) and notifications
+     * Handle inbound JSON-RPC messages from the transport.
+     *
+     * Processes both responses (for requests) and notifications. Non-JSON-RPC
+     * payloads are silently ignored so that a shared transport can be used for
+     * multiple protocols without cross-talk.
      */
     private onMessage;
     /**
-     * Send a JSON-RPC request to the parent window
+     * Send a JSON-RPC request to the peer.
      *
      * @param method - The JSON-RPC method name
      * @param params - The method parameters
@@ -58,7 +140,7 @@ export declare class JsonRpcClient {
      */
     protected request<TParams = unknown, TResult = unknown>(method: string, params: TParams): Promise<TResult>;
     /**
-     * Send a JSON-RPC notification to the parent window
+     * Send a JSON-RPC notification to the peer.
      *
      * Notifications are one-way messages that do not expect a response.
      * Use notifications for:

package/dist/jsonrpc-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonrpc-client.d.ts","sourceRoot":"","sources":["../src/jsonrpc-client.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,aAAa;IACzB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,oBAAoB,CAAqD;;IAOjF;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI;IAO/F;;;OAGG;IACH,OAAO,CAAC,SAAS,CA4Bf;IAEF;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,OAAO,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACrD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,GACb,OAAO,CAAC,OAAO,CAAC;IAkBnB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,CAAC,gBAAgB,CAAC,OAAO,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;CAQrF"}
+{"version":3,"file":"jsonrpc-client.d.ts","sourceRoot":"","sources":["../src/jsonrpc-client.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,SAAS;IACzB;;;;;OAKG;IAEH,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAE7B;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC5D;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,0BAA2B,YAAW,SAAS;IAC3D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC;;;;;OAKG;gBACS,YAAY,SAAM;IAI9B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI5B,SAAS,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI;CAO3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,aAAa;IACzB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,oBAAoB,CAAqD;IACjF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IAEtC;;;;;;OAMG;gBACS,SAAS,GAAE,SAA4C;IAMnE;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI;IAO/F;;;;;;OAMG;IACH,OAAO,CAAC,SAAS,CA0Bf;IAEF;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,OAAO,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACrD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,GACb,OAAO,CAAC,OAAO,CAAC;IAkBnB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,SAAS,CAAC,gBAAgB,CAAC,OAAO,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;CAQrF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/sdk-core",
-  "version": "1.131.1",
+  "version": "1.131.3",
   "license": "SEE LICENSE IN LICENSE.txt",
   "type": "module",
   "main": "./dist/index.js",