@salesforce/sdk-core 1.132.0 → 1.133.1

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export type { JsonRpcBase, JsonRpcRequest, JsonRpcError, JsonRpcSuccessResponse,
 export { isJsonRpcBase, isJsonRpcSuccessResponse, isJsonRpcErrorResponse, isJsonRpcResponse, isJsonRpcNotification, isJsonRpcRequest, } from './jsonrpc';
 export { JsonRpcClient, WindowPostMessageTransport } from './jsonrpc-client';
 export type { Transport } from './jsonrpc-client';
+export { MessageChannelTransport, type MessageChannelTransportListener, } from './mfe-protocol/message-channel-transport';
 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,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"}
+{"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;AAKlD,OAAO,EACN,uBAAuB,EACvB,KAAK,+BAA+B,GACpC,MAAM,0CAA0C,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,6 +1,6 @@
-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() {
+var o = /* @__PURE__ */ ((t) => (t.WebApp = "WebApp", t.MicroFrontend = "Micro-Frontend", t.OpenAI = "OpenAI", t.SalesforceACC = "Salesforce-ACC", t.MCPApps = "MCP-Apps", t.Mosaic = "Mosaic", t))(o || {});
+const f = d();
+function d() {
   if (typeof window > "u")
     return "Mosaic";
   if (window.openai)
@@ -11,29 +11,29 @@ function f() {
   } catch {
     return "Micro-Frontend";
   }
-  const e = window;
-  return e.$A || e.Aura ? "Salesforce-ACC" : "WebApp";
+  const t = window;
+  return t.$A || t.Aura ? "Salesforce-ACC" : "WebApp";
 }
-function S(e) {
-  return e ?? d;
+function S(t) {
+  return t ?? f;
 }
-function l(e) {
-  return typeof e == "object" && e !== null && "jsonrpc" in e && e.jsonrpc === "2.0";
+function u(t) {
+  return typeof t == "object" && t !== null && "jsonrpc" in t && t.jsonrpc === "2.0";
 }
-function p(e) {
-  return l(e) && "id" in e && typeof e.id == "number" && "result" in e;
+function h(t) {
+  return u(t) && "id" in t && typeof t.id == "number" && "result" in t;
 }
-function u(e) {
-  return l(e) && "id" in e && typeof e.id == "number" && "error" in e;
+function l(t) {
+  return u(t) && "id" in t && typeof t.id == "number" && "error" in t;
 }
-function h(e) {
-  return p(e) || u(e);
+function p(t) {
+  return h(t) || l(t);
 }
-function g(e) {
-  return l(e) && "method" in e && typeof e.method == "string" && !("id" in e);
+function g(t) {
+  return u(t) && "method" in t && typeof t.method == "string" && !("id" in t);
 }
-function b(e) {
-  return l(e) && "id" in e && typeof e.id == "number" && "method" in e && typeof e.method == "string";
+function R(t) {
+  return u(t) && "id" in t && typeof t.id == "number" && "method" in t && typeof t.method == "string";
 }
 class T {
   targetOrigin;
@@ -43,15 +43,15 @@ class T {
    *   compatibility. Pin to the known parent origin when possible to
    *   prevent leaking messages to a cross-origin navigated parent.
    */
-  constructor(t = "*") {
-    this.targetOrigin = t;
+  constructor(e = "*") {
+    this.targetOrigin = e;
   }
-  post(t) {
-    window.parent?.postMessage(t, this.targetOrigin);
+  post(e) {
+    window.parent?.postMessage(e, this.targetOrigin);
   }
-  onMessage(t) {
+  onMessage(e) {
     const s = (n) => {
-      t(n.data);
+      e(n.data);
     };
     return window.addEventListener("message", s), () => window.removeEventListener("message", s);
   }
@@ -68,8 +68,8 @@ class M {
    *   `WindowPostMessageTransport`, which preserves the original
    *   `window.parent.postMessage` behaviour.
    */
-  constructor(t = new T()) {
-    this.transport = t, this.transport.onMessage(this.onMessage);
+  constructor(e = new T()) {
+    this.transport = e, this.transport.onMessage(this.onMessage);
   }
   /**
    * Register a handler for a specific JSON-RPC notification method
@@ -86,8 +86,8 @@ class M {
    *   this.handleHostContextChanged(params);
    * });
    */
-  registerNotificationHandler(t, s) {
-    this.notificationHandlers.has(t) || this.notificationHandlers.set(t, /* @__PURE__ */ new Set()), this.notificationHandlers.get(t).add(s);
+  registerNotificationHandler(e, s) {
+    this.notificationHandlers.has(e) || this.notificationHandlers.set(e, /* @__PURE__ */ new Set()), this.notificationHandlers.get(e).add(s);
   }
   /**
    * Handle inbound JSON-RPC messages from the transport.
@@ -96,17 +96,17 @@ class M {
    * payloads are silently ignored so that a shared transport can be used for
    * multiple protocols without cross-talk.
    */
-  onMessage = (t) => {
-    if (h(t)) {
-      const s = this.pending.get(t.id);
+  onMessage = (e) => {
+    if (p(e)) {
+      const s = this.pending.get(e.id);
       if (!s)
         return;
-      this.pending.delete(t.id), u(t) ? s.reject(new Error(t.error.message || "Request failed")) : s.resolve(t.result);
+      this.pending.delete(e.id), l(e) ? s.reject(new Error(e.error.message || "Request failed")) : s.resolve(e.result);
       return;
     }
-    if (g(t)) {
-      const s = this.notificationHandlers.get(t.method);
-      s && s.forEach((n) => n(t.params));
+    if (g(e)) {
+      const s = this.notificationHandlers.get(e.method);
+      s && s.forEach((n) => n(e.params));
     }
   };
   /**
@@ -122,16 +122,16 @@ class M {
    *   content: { type: "text", text: "Hello" }
    * });
    */
-  request(t, s) {
+  request(e, s) {
     const n = this.nextRequestId++, r = {
       jsonrpc: "2.0",
       id: n,
-      method: t,
+      method: e,
       params: s
     };
-    return new Promise((o, c) => {
+    return new Promise((i, c) => {
       this.pending.set(n, {
-        resolve: o,
+        resolve: i,
         reject: c
       }), this.transport.post(r);
     });
@@ -159,16 +159,114 @@ class M {
    *   height: 600
    * });
    */
-  sendNotification(t, s) {
+  sendNotification(e, s) {
     const n = {
       jsonrpc: "2.0",
-      method: t,
+      method: e,
       params: s
     };
     this.transport.post(n);
   }
 }
-const C = 500, w = "2026-01-26";
+function y() {
+}
+class H {
+  #e;
+  #s = /* @__PURE__ */ new Set();
+  #i = !1;
+  #n = !1;
+  /** Messages queued before `port.start()` has been called. Flushed on first subscribe. */
+  #t = [];
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * Post a message to the peer.
+   *
+   * Never throws on transient failure — a closed / neutered / disposed
+   * port silently drops the message. If the transport has not yet
+   * started (no `onMessage` subscriber), the message is buffered and
+   * flushed on first subscription.
+   */
+  post(e) {
+    if (!this.#n) {
+      if (!this.#i) {
+        this.#t.push(e);
+        return;
+      }
+      try {
+        this.#e.postMessage(e);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Subscribe to inbound messages from the peer. The callback receives
+   * the **unwrapped** payload (`MessageEvent.data`) — callers never see
+   * the `MessageEvent` wrapper.
+   *
+   * Starts the underlying port on first subscription and flushes any
+   * messages queued via `post` before the port was started.
+   *
+   * Returns an unsubscribe function. Calling it is idempotent.
+   */
+  onMessage(e) {
+    if (this.#n)
+      return y;
+    this.#s.add(e), this.#i || this.#r();
+    let s = !1;
+    return () => {
+      s || (s = !0, this.#s.delete(e));
+    };
+  }
+  /**
+   * Tear down the transport:
+   *  - remove the internal `message` listener
+   *  - call `port.close()`
+   *  - clear subscriber set and outbound buffer
+   *  - subsequent `post` calls silently no-op
+   *  - subsequent `onMessage` calls return a no-op unsubscribe
+   */
+  dispose() {
+    if (!this.#n) {
+      this.#n = !0;
+      try {
+        this.#e.removeEventListener("message", this.#o);
+      } catch {
+      }
+      this.#s.clear(), this.#t.length = 0;
+      try {
+        this.#e.close();
+      } catch {
+      }
+    }
+  }
+  #r() {
+    this.#i = !0, this.#e.addEventListener("message", this.#o);
+    try {
+      this.#e.start();
+    } catch {
+    }
+    if (this.#t.length > 0) {
+      const e = this.#t;
+      this.#t = [];
+      for (const s of e)
+        try {
+          this.#e.postMessage(s);
+        } catch {
+        }
+    }
+  }
+  #o = (e) => {
+    const s = [...this.#s];
+    for (const n of s)
+      try {
+        n(e.data);
+      } catch {
+      }
+  };
+}
+const m = 500, C = "2026-01-26";
 class a extends M {
   static initPromise = null;
   hostCtx = {};
@@ -179,10 +277,10 @@ class a extends M {
    * The first call performs the SEP-1865 handshake. Concurrent and subsequent
    * calls reuse the same session and handshake result.
    */
-  static async getInstance(t) {
+  static async getInstance(e) {
     return a.initPromise || (a.initPromise = (async () => {
       const s = new a();
-      return await s.handshake(t), s;
+      return await s.handshake(e), s;
     })()), a.initPromise;
   }
   /**
@@ -199,18 +297,18 @@ class a extends M {
    * 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(t) {
-    const s = t?.handshakeTimeoutMs ?? C, n = t?.appInfo ?? { name: "mcp-app", version: "1.0.0" };
+  async handshake(e) {
+    const s = e?.handshakeTimeoutMs ?? m, n = e?.appInfo ?? { name: "mcp-app", version: "1.0.0" };
     try {
-      const r = /* @__PURE__ */ Symbol("timeout"), o = await Promise.race([
+      const r = /* @__PURE__ */ Symbol("timeout"), i = await Promise.race([
         this.request("ui/initialize", {
-          protocolVersion: w,
+          protocolVersion: C,
           appInfo: n,
           appCapabilities: {}
         }),
         new Promise((c) => setTimeout(() => c(r), s))
       ]);
-      o !== r && (this.hostCtx = o.hostContext ?? {}, this._handshakeSucceeded = !0, this.registerNotificationHandler("ui/notifications/host-context-changed", (c) => {
+      i !== r && (this.hostCtx = i.hostContext ?? {}, this._handshakeSucceeded = !0, this.registerNotificationHandler("ui/notifications/host-context-changed", (c) => {
         this.hostCtx = {
           ...this.hostCtx,
           ...c
@@ -230,17 +328,17 @@ class a extends M {
   // ── Public wrappers ──────────────────────────────────────────────────
   // Widen access from protected to public so SDK classes can use the
   // shared transport without extending JsonRpcClient themselves.
-  request(t, s) {
-    return super.request(t, s);
+  request(e, s) {
+    return super.request(e, s);
   }
-  sendNotification(t, s) {
-    super.sendNotification(t, s);
+  sendNotification(e, s) {
+    super.sendNotification(e, s);
   }
-  registerNotificationHandler(t, s) {
-    super.registerNotificationHandler(t, s);
+  registerNotificationHandler(e, s) {
+    super.registerNotificationHandler(e, s);
   }
 }
-const m = {
+const w = {
   callTool: !0,
   sendMessageToHost: !0,
   readResource: !0,
@@ -260,7 +358,7 @@ const m = {
   // TODO
   getTheme: !0,
   resize: !0
-}, y = {
+}, A = {
   callTool: !0,
   sendMessageToHost: !0,
   readResource: !1,
@@ -279,7 +377,7 @@ const m = {
   displayModal: !0,
   getTheme: !0,
   resize: !1
-}, A = {
+}, I = {
   callTool: !1,
   sendMessageToHost: !0,
   readResource: !1,
@@ -298,7 +396,7 @@ const m = {
   displayModal: !1,
   getTheme: !0,
   resize: !1
-}, I = {
+}, b = {
   callTool: !1,
   sendMessageToHost: !1,
   readResource: !1,
@@ -318,32 +416,32 @@ const m = {
   getTheme: !1,
   resize: !1
 };
-function R(e) {
-  switch (e) {
-    case i.MCPApps:
-      return { ...m };
-    case i.OpenAI:
-      return { ...y };
-    case i.SalesforceACC:
+function E(t) {
+  switch (t) {
+    case o.MCPApps:
+      return { ...w };
+    case o.OpenAI:
       return { ...A };
-    case i.Mosaic:
-    case i.WebApp:
-    case i.MicroFrontend:
-    default:
+    case o.SalesforceACC:
       return { ...I };
+    case o.Mosaic:
+    case o.WebApp:
+    case o.MicroFrontend:
+    default:
+      return { ...b };
   }
 }
 const P = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
-function H(e, t) {
-  return new Proxy(e, {
+function O(t, e) {
+  return new Proxy(t, {
     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;
+        const i = Reflect.get(s, n, r);
+        return typeof i == "function" ? i.bind(s) : i;
       }
       throw new TypeError(
-        `\`${t}()\` returns a Promise — did you forget to await it?
-Use \`const sdk = await ${t}();\` before accessing SDK methods.`
+        `\`${e}()\` returns a Promise — did you forget to await it?
+Use \`const sdk = await ${e}();\` before accessing SDK methods.`
       );
     }
   });
@@ -351,15 +449,16 @@ Use \`const sdk = await ${t}();\` before accessing SDK methods.`
 export {
   M as JsonRpcClient,
   a as McpAppsSession,
-  i as Surface,
+  H as MessageChannelTransport,
+  o as Surface,
   T as WindowPostMessageTransport,
   S as getSurface,
-  R as getSurfaceCapabilities,
-  l as isJsonRpcBase,
-  u as isJsonRpcErrorResponse,
+  E as getSurfaceCapabilities,
+  u as isJsonRpcBase,
+  l as isJsonRpcErrorResponse,
   g as isJsonRpcNotification,
-  b as isJsonRpcRequest,
-  h as isJsonRpcResponse,
-  p as isJsonRpcSuccessResponse,
-  H as wrapSDKPromise
+  R as isJsonRpcRequest,
+  p as isJsonRpcResponse,
+  h as isJsonRpcSuccessResponse,
+  O as wrapSDKPromise
 };

package/dist/mfe-protocol/message-channel-transport.d.ts

@@ -0,0 +1,79 @@
+import { Transport } from '../jsonrpc-client';
+/**
+ * Subscriber callback invoked for each unwrapped payload delivered on the
+ * port. Receivers get the `MessageEvent.data` directly — they do not need
+ * to reach into a `MessageEvent` wrapper.
+ */
+export type MessageChannelTransportListener = (msg: unknown) => void;
+/**
+ * MFE-side `Transport` backed by a `MessagePort`.
+ *
+ * During the MFE handshake, the iframe receives a transferred `MessagePort`
+ * (`event.ports[0]`) in the single bootstrap envelope posted by the host.
+ * That port is the `port1` half of the host's `MessageChannel`. Wrapping it
+ * in this class produces the same `Transport` shape that `JsonRpcClient`
+ * already consumes, so callers can swap in MessagePort-backed traffic
+ * without changing any of the JSON-RPC request/response/notification
+ * semantics.
+ *
+ * The implementation mirrors the host-side `MessageChannelTransport` that
+ * ships from `packages/core/src/MessageChannelTransport.ts` in the
+ * `ui-embedding` repo. Both sides MUST honour the same contract so one
+ * `JsonRpcClient` can drive either end.
+ *
+ * Contract (symmetric with the host-side transport, and with the
+ * `Transport` interface defined next to `WindowPostMessageTransport`):
+ *
+ *  - `post(msg)` never throws on transient failure. A closed / neutered /
+ *    disposed port silently drops the message. This matches the
+ *    optional-chaining behaviour of `WindowPostMessageTransport.post`.
+ *  - `onMessage(cb)` delivers the **unwrapped** payload (`MessageEvent.data`),
+ *    not the raw `MessageEvent`. Returns an unsubscribe function.
+ *  - The port is started (`port.start()`) lazily on the first `onMessage`
+ *    subscription. Messages queued via `post` before that first subscribe
+ *    are buffered in-process and flushed FIFO when the port starts.
+ *  - `dispose()` removes listeners, closes the port, clears the outbound
+ *    buffer, and puts the transport into a terminal state where further
+ *    `post` calls silently no-op and further `onMessage` calls return a
+ *    no-op unsubscribe.
+ *
+ * Usage from the container bootstrap:
+ * ```ts
+ * const transport = new MessageChannelTransport(event.ports[0]);
+ * // Hand the transport to the session layer; subscription drives start().
+ * ```
+ */
+export declare class MessageChannelTransport implements Transport {
+    #private;
+    constructor(port: MessagePort);
+    /**
+     * Post a message to the peer.
+     *
+     * Never throws on transient failure — a closed / neutered / disposed
+     * port silently drops the message. If the transport has not yet
+     * started (no `onMessage` subscriber), the message is buffered and
+     * flushed on first subscription.
+     */
+    post(message: unknown): void;
+    /**
+     * Subscribe to inbound messages from the peer. The callback receives
+     * the **unwrapped** payload (`MessageEvent.data`) — callers never see
+     * the `MessageEvent` wrapper.
+     *
+     * Starts the underlying port on first subscription and flushes any
+     * messages queued via `post` before the port was started.
+     *
+     * Returns an unsubscribe function. Calling it is idempotent.
+     */
+    onMessage(callback: MessageChannelTransportListener): () => void;
+    /**
+     * Tear down the transport:
+     *  - remove the internal `message` listener
+     *  - call `port.close()`
+     *  - clear subscriber set and outbound buffer
+     *  - subsequent `post` calls silently no-op
+     *  - subsequent `onMessage` calls return a no-op unsubscribe
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=message-channel-transport.d.ts.map

package/dist/mfe-protocol/message-channel-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-channel-transport.d.ts","sourceRoot":"","sources":["../../src/mfe-protocol/message-channel-transport.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;GAIG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;AAUrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,uBAAwB,YAAW,SAAS;;gBAQ5C,IAAI,EAAE,WAAW;IAI7B;;;;;;;OAOG;IACH,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAqB5B;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,EAAE,+BAA+B,GAAG,MAAM,IAAI;IAoBhE;;;;;;;OAOG;IACH,OAAO,IAAI,IAAI;CAyDf"}

package/package.json

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