@microsoft/power-apps-native-host 0.2.25 → 0.3.3

package/lib/commonjs/telemetry/OfflineSdkTelemetry.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configureOfflineSdkTelemetry = configureOfflineSdkTelemetry;
+var _powerAppsNativeCommon = require("@microsoft/power-apps-native-common");
+var OfflineSdk = _interopRequireWildcard(require("@microsoft/power-apps-native-offline"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Operation names for this adapter's own diagnostics, following the
+ * `PowerAppsHost.<Subsystem>.<Action>` convention used by `HostOperationNames`.
+ *
+ * Declared locally rather than imported from `./index`: this module must stay
+ * fail-open and side-effect free, and the barrel constructs HTTP clients at
+ * import time. Two string constants are not worth that dependency.
+ */
+const OfflineTelemetryBindFailed = 'PowerAppsHost.Offline.TelemetryBind.Failed';
+const OfflineTelemetryUnbindFailed = 'PowerAppsHost.Offline.TelemetryUnbind.Failed';
+
+/**
+ * Non-sensitive error discriminator. Records the error's constructor name only,
+ * never its message, so diagnostics cannot leak user or tenant data.
+ */
+function getSafeErrorName(error) {
+  return error instanceof Error ? error.constructor.name : typeof error;
+}
+
+/**
+ * True when the resolved SDK exposes the v1 host-telemetry transport.
+ *
+ * Reading a missing export yields `undefined` rather than throwing, so this
+ * probe is safe on SDK builds that predate the transport. Keeping it separate
+ * from the `try`/`catch` below is what lets an out-of-range SDK stay a silent,
+ * expected no-op while genuine wiring failures still get reported.
+ *
+ * The version equality matters as much as the `typeof`: a future transport
+ * revision with a different sink shape would accept a v1 sink and silently
+ * malform every event rather than throw.
+ */
+function isTransportSupported() {
+  return typeof OfflineSdk.configureOfflineHostTelemetry === 'function' && OfflineSdk.OFFLINE_HOST_TELEMETRY_TRANSPORT_VERSION === 1;
+}
+
+/**
+ * Forwards the privacy-safe Offline SDK transport through the host's existing
+ * app logger so offline events carry the same session, device, and user data.
+ *
+ * The host owns exactly one thing here: binding the SDK transport to this
+ * host's logger. Buffering and teardown semantics live in the SDK.
+ *
+ * Setup and teardown are fail-open but not silent. This runs from an effect in
+ * the provider that roots the app, so an unguarded throw would take down the
+ * whole tree — telemetry is never worth an app that will not start. An
+ * unexpected failure is therefore downgraded to a logged diagnostic rather than
+ * swallowed, so broken wiring stays observable.
+ */
+function configureOfflineSdkTelemetry(forwardEvents) {
+  if (!isTransportSupported()) {
+    return () => undefined;
+  }
+  const stopForwarding = () => {
+    try {
+      OfflineSdk.configureOfflineHostTelemetry(undefined);
+    } catch (e) {
+      (0, _powerAppsNativeCommon.getAppLogger)().trackErrorEvent(OfflineTelemetryUnbindFailed, {
+        errorName: getSafeErrorName(e)
+      });
+    }
+  };
+  if (!forwardEvents) {
+    stopForwarding();
+    return stopForwarding;
+  }
+  try {
+    OfflineSdk.configureOfflineHostTelemetry({
+      // Resolved per event, not captured: the Dev Player swaps the logger when
+      // it switches apps, and a captured instance would strand events.
+      //
+      // `name` is the operation name only. Deliberately not passed as the
+      // optional third `eventName` argument: that overrides the canonical
+      // `PowerAppsClient.Activity`/`.Error` 1DS event names, which would hide
+      // every offline event from the queries and dashboards that filter on
+      // them. The name already reaches 1DS as `operation_Name`.
+      trackActivityEvent: (name, properties) => (0, _powerAppsNativeCommon.getAppLogger)().trackActivityEvent(name, properties),
+      trackErrorEvent: (name, properties) => (0, _powerAppsNativeCommon.getAppLogger)().trackErrorEvent(name, properties)
+    });
+  } catch (e) {
+    (0, _powerAppsNativeCommon.getAppLogger)().trackErrorEvent(OfflineTelemetryBindFailed, {
+      errorName: getSafeErrorName(e)
+    });
+    return () => undefined;
+  }
+  return stopForwarding;
+}

package/lib/commonjs/telemetry/OfflineSdkTelemetry.web.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configureOfflineSdkTelemetry = configureOfflineSdkTelemetry;
+function configureOfflineSdkTelemetry(_forwardEvents) {
+  return () => undefined;
+}

package/lib/commonjs/telemetry/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.HostOperationNames = void 0;
+exports.bridgeHttpClient = exports.HostOperationNames = void 0;
 Object.defineProperty(exports, "configureAppLogger", {
   enumerable: true,
   get: function () {
@@ -16,6 +16,15 @@ Object.defineProperty(exports, "getAppLogger", {
     return _powerAppsNativeCommon.getAppLogger;
   }
 });
+Object.defineProperty(exports, "getCustomerTelemetryLogger", {
+  enumerable: true,
+  get: function () {
+    return _powerAppsNativeCommon.getCustomerTelemetryLogger;
+  }
+});
+exports.platformHttpClient = void 0;
+var _http = require("@microsoft/power-apps-native-common/http");
+var _logger = require("../logger.js");
 var _powerAppsNativeCommon = require("@microsoft/power-apps-native-common");
 /*!
  * Copyright (C) Microsoft Corporation. All rights reserved.
@@ -57,14 +66,24 @@ const HostOperationNames = exports.HostOperationNames = {
   /** Top-level React error boundary caught an unhandled JS error. */
   RuntimeUnhandledJsError: 'PowerAppsHost.Runtime.UnhandledJsError',
   // ── Platform APIs ─────────────────────────────────────────────────────────
+  /** Power Platform RP HTTP request, including backend correlation IDs. */
+  PlatformHttpRequest: 'PowerAppsHost.Platform.HttpRequest',
   /** Resolve Dataverse instanceUrl from Power Platform environment API. */
   PlatformFetchInstanceUrl: 'PowerAppsHost.Platform.FetchInstanceUrl',
   /** useConnectionRefs failed to resolve connections (recoverable). Recorded only on failure. */
   PlatformLoadConnectionsFailed: 'PowerAppsHost.Platform.LoadConnections.Failed',
   /** Create a new Power Platform connection. */
   PlatformCreateConnection: 'PowerAppsHost.Platform.CreateConnection',
+  /** Repair an existing Power Platform connection. */
+  PlatformRepairConnection: 'PowerAppsHost.Platform.RepairConnection',
+  /** Poll a connection until it becomes active. */
+  PlatformPollConnectionStatus: 'PowerAppsHost.Platform.PollConnectionStatus',
   /** Resolve app connection references for the current launch. */
   PlatformResolveConnectionRefs: 'PowerAppsHost.Platform.ResolveConnectionRefs',
   /** Grant this app access to a Power Platform connection ACL. */
-  PlatformConnectionAclGrant: 'PowerAppsHost.Platform.ConnectionAclGrant'
-};
+  PlatformConnectionAclGrant: 'PowerAppsHost.Platform.ConnectionAclGrant',
+  /** Installed Offline SDK predates the SDK-owned routing contract. */
+  OfflineRoutingContractUnsupported: 'PowerAppsHost.Offline.RoutingContract.Unsupported'
+};
+const bridgeHttpClient = exports.bridgeHttpClient = new _http.HttpClient(HostOperationNames.BridgeHttpRequest, _logger.isDebugLoggingEnabled);
+const platformHttpClient = exports.platformHttpClient = new _http.HttpClient(HostOperationNames.PlatformHttpRequest, _logger.isDebugLoggingEnabled);

package/lib/module/auth/AuthContext.js

@@ -31,10 +31,75 @@ const SIGN_IN_SCOPES = ['https://api.powerplatform.com/.default'];
 function getSafeErrorName(error) {
   return error instanceof Error ? error.constructor.name : typeof error;
 }
+function getErrorProperty(error, propertyName) {
+  return error && typeof error === 'object' ? error[propertyName] : undefined;
+}
+function getSafeErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === 'string' ? error : String(error);
+}
+function getAuthErrorTelemetry(error) {
+  const errorMessage = getSafeErrorMessage(error);
+  const parsedNSError = /domain=([^\s]+) code=(-?\d+)/.exec(errorMessage);
+  return {
+    errorName: getSafeErrorName(error),
+    errorCode: getErrorProperty(error, 'code'),
+    nativeErrorDomain: getErrorProperty(error, 'nativeErrorDomain') ?? parsedNSError?.[1],
+    nativeErrorCode: getErrorProperty(error, 'nativeErrorCode') ?? parsedNSError?.[2],
+    nativeErrorMessage: errorMessage.slice(0, 512)
+  };
+}
+function getAuthTelemetryProperties(useBroker, useEmbeddedWebView) {
+  return {
+    authMode: useBroker ? 'wrap' : 'nonWrap',
+    platform: Platform.OS,
+    useBroker,
+    useEmbeddedWebView
+  };
+}
+function accountsMatch(left, right) {
+  return left.identifier === right.identifier && left.tenantId === right.tenantId;
+}
+async function validateRequiredScopes(pca, account, scopes) {
+  for (const scope of scopes) {
+    await pca.acquireTokenSilent({
+      scopes: [scope],
+      account
+    });
+  }
+}
+async function acquireRequiredScopesInteractively(pca, scopes) {
+  const [primaryScope, ...additionalScopes] = scopes;
+  const primaryResult = await pca.acquireToken({
+    scopes: [primaryScope],
+    prompt: 'select_account'
+  });
+  const signedInAccount = primaryResult.account;
+  for (const scope of additionalScopes) {
+    try {
+      await pca.acquireTokenSilent({
+        scopes: [scope],
+        account: signedInAccount
+      });
+    } catch {
+      const result = await pca.acquireToken({
+        scopes: [scope],
+        loginHint: signedInAccount.username,
+        prompt: 'login'
+      });
+      if (!accountsMatch(signedInAccount, result.account)) {
+        throw new Error('Sign in with the same account for all required Power Platform permissions.');
+      }
+    }
+  }
+  await validateRequiredScopes(pca, signedInAccount, scopes);
+  return signedInAccount;
+}
 const AuthContext = /*#__PURE__*/createContext(null);
 export function AuthProvider({
   msalConfig,
   intuneConfig,
+  requiredScopes = [],
   children
 }) {
   const [isAuthReady, setIsAuthReady] = useState(false);
@@ -99,6 +164,8 @@ export function AuthProvider({
   // Skip MSAL entirely; treat the session as already signed in so the app
   // renders without requiring credentials.
   const noAuthMode = !effectiveClientId;
+  const requiredScopeKey = [...new Set(requiredScopes)].join('|');
+  const effectiveRequiredScopes = requiredScopeKey ? requiredScopeKey.split('|') : SIGN_IN_SCOPES;
   const pcaRef = useRef(null);
   useEffect(() => {
     if (noAuthMode) {
@@ -120,12 +187,22 @@ export function AuthProvider({
       } : {})
     });
     pcaRef.current = pca;
-    const authInitScenario = getAppLogger().trackScenario(HostOperationNames.AuthInit, {
-      useBroker,
-      platform: Platform.OS
-    });
-    pca.init().then(() => pca.getAccounts()).then(accounts => {
-      const restoredAccount = accounts[0] ?? null;
+    const authTelemetryProperties = getAuthTelemetryProperties(useBroker, useEmbeddedWebView);
+    const authInitScenario = getAppLogger().trackScenario(HostOperationNames.AuthInit, authTelemetryProperties);
+    pca.init().then(() => pca.getAccounts()).then(async accounts => {
+      let restoredAccount = accounts[0] ?? null;
+      if (restoredAccount) {
+        try {
+          await validateRequiredScopes(pca, restoredAccount, effectiveRequiredScopes);
+        } catch (tokenError) {
+          await pca.signOut({
+            account: restoredAccount
+          }).catch(() => undefined);
+          restoredAccount = null;
+          setError(new Error('Your session has expired. Sign in again to continue.'));
+          debugWarn('[AuthProvider] restored account is missing a required token:', tokenError);
+        }
+      }
       setAccount(restoredAccount);
       if (restoredAccount) {
         getAppLogger().identifyUser({
@@ -143,33 +220,28 @@ export function AuthProvider({
       setError(e instanceof Error ? e : new Error(String(e)));
       setIsAuthReady(true);
       setIsLoading(false);
-      authInitScenario.fail(undefined, {
-        errorName: getSafeErrorName(e)
-      });
+      authInitScenario.fail(undefined, getAuthErrorTelemetry(e));
     });
     // Re-initialize only when the effective broker/identity settings change.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [effectiveClientId, effectiveTenantId, effectiveRedirectUri, useBroker]);
+  }, [effectiveClientId, effectiveTenantId, effectiveRedirectUri, requiredScopeKey, useBroker]);
   const signIn = useCallback(async () => {
     const pca = pcaRef.current;
     if (!pca) return;
     setIsLoading(true);
     setError(null);
-    const signInScenario = getAppLogger().trackScenario(HostOperationNames.AuthSignIn, {
-      useBroker
-    });
+    const authTelemetryProperties = getAuthTelemetryProperties(useBroker, useEmbeddedWebView);
+    const signInScenario = getAppLogger().trackScenario(HostOperationNames.AuthSignIn, authTelemetryProperties);
     try {
       // If init() failed on mount, retry it now before attempting sign-in.
       if (!pca.isInitialized) {
         await pca.init();
       }
-      const result = await pca.acquireToken({
-        scopes: SIGN_IN_SCOPES
-      });
-      setAccount(result.account);
+      const signedInAccount = await acquireRequiredScopesInteractively(pca, effectiveRequiredScopes);
+      setAccount(signedInAccount);
       getAppLogger().identifyUser({
-        objectId: result.account.identifier,
-        tenantId: result.account.tenantId
+        objectId: signedInAccount.identifier,
+        tenantId: signedInAccount.tenantId
       });
       // Register the signed-in account with Intune MAM so the SDK can apply
       // app protection policies (PIN, wipe, copy-paste restriction, etc.).
@@ -178,9 +250,9 @@ export function AuthProvider({
       if (intuneEnabled) {
         try {
           await registerAndEnrollAccount({
-            upn: result.account.username,
-            aadId: result.account.identifier,
-            tenantId: result.account.tenantId
+            upn: signedInAccount.username,
+            aadId: signedInAccount.identifier,
+            tenantId: signedInAccount.tenantId
           });
           getAppLogger().trackActivityEvent(HostOperationNames.AuthIntuneEnroll);
         } catch (intuneErr) {
@@ -188,20 +260,19 @@ export function AuthProvider({
           // Intune Conditional Access on the next token acquisition.
           debugWarn('[AuthProvider] Intune enrollment failed:', intuneErr);
           getAppLogger().trackErrorEvent(HostOperationNames.AuthIntuneEnroll, {
-            errorName: getSafeErrorName(intuneErr)
+            ...authTelemetryProperties,
+            ...getAuthErrorTelemetry(intuneErr)
           });
         }
       }
       signInScenario.complete();
     } catch (e) {
       setError(e instanceof Error ? e : new Error(String(e)));
-      signInScenario.fail(undefined, {
-        errorName: getSafeErrorName(e)
-      });
+      signInScenario.fail(undefined, getAuthErrorTelemetry(e));
     } finally {
       setIsLoading(false);
     }
-  }, [intuneEnabled, useBroker]);
+  }, [intuneEnabled, requiredScopeKey, useBroker]);
   const acquireToken = useCallback(async scopes => {
     const pca = pcaRef.current;
     if (!pca || !account) return null;
@@ -212,18 +283,24 @@ export function AuthProvider({
       });
       return result.accessToken;
     } catch (e) {
-      // Silent acquisition failed — do NOT fall back to interactive here.
-      // Interactive sign-in is handled exclusively by signIn(). Falling back
-      // to interactive from acquireToken triggers an unexpected login webview
-      // whenever a connector needs a token the cache doesn't hold yet.
       debugWarn('[AuthContext] acquireTokenSilent failed for scopes:', scopes, e);
       getAppLogger().trackErrorEvent(HostOperationNames.AuthAcquireTokenSilentFailed, {
+        ...getAuthTelemetryProperties(useBroker, useEmbeddedWebView),
         scopeCount: scopes.length,
-        errorName: getSafeErrorName(e)
+        ...getAuthErrorTelemetry(e)
       });
+      if (scopes.some(scope => effectiveRequiredScopes.includes(scope))) {
+        await pca.signOut({
+          account
+        }).catch(signOutError => {
+          debugWarn('[AuthContext] failed to clear an invalid session:', signOutError);
+        });
+        setError(new Error('Your session has expired. Sign in again to continue.'));
+        setAccount(null);
+      }
       return null;
     }
-  }, [account]);
+  }, [account, requiredScopeKey]);
   const signOut = useCallback(async () => {
     const pca = pcaRef.current;
     if (!pca || !account) return;

package/lib/module/bridge/NativePowerAppsBridge.js

@@ -12,8 +12,10 @@
  */
 
 import { debugLog, debugWarn } from "../logger.js";
-import { getAppLogger, HostOperationNames } from "../telemetry/index.js";
+import { bridgeHttpClient, getAppLogger, HostOperationNames } from "../telemetry/index.js";
+import { getHttpCorrelationProperties } from '@microsoft/power-apps-native-common/http';
 import { sanitizeUrl } from '@microsoft/power-apps-native-common';
+import { assertSuccessfulHttpStatus, getRequestBodyForMethod, updateBridgeOptionsInPlace } from "./bridgeState.js";
 function getSafeErrorName(error) {
   return error instanceof Error ? error.constructor.name : typeof error;
 }
@@ -115,7 +117,7 @@ export class NativePowerAppsBridge {
    * via globalThis would have no effect — mutating options is the correct path.
    */
   updateOptions(options) {
-    this._options = options;
+    this._options = updateBridgeOptionsInPlace(this._options, options);
   }
   async initialize() {
     // No handshake required for the native path.
@@ -198,10 +200,6 @@ export class NativePowerAppsBridge {
       method
     } = requestConfig;
     const urlLabel = sanitizeUrl(url.replace(/^https?:\/\/[^/]+/, '').slice(0, 100));
-    const scenario = getAppLogger().trackScenario(HostOperationNames.BridgeHttpRequest, {
-      httpMethod: method,
-      url: urlLabel
-    });
     const isBlob = bodyParam instanceof Blob;
 
     // The SDK builds Authorization headers with the "paauth" scheme (its web-player
@@ -226,11 +224,12 @@ export class NativePowerAppsBridge {
       // SDK passed a plain object — JSON-stringify it as a fallback
       bodyInit = JSON.stringify(bodyParam);
     }
+    bodyInit = getRequestBodyForMethod(method, bodyInit);
     headers = normalizeJsonBodyHeaders(headers, bodyInit);
     debugLog(`[bridge] → ${method} ${urlLabel}`);
     let response;
     try {
-      response = await fetch(url, {
+      response = await bridgeHttpClient.request(url, {
         method,
         headers: headers,
         body: bodyInit
@@ -238,9 +237,6 @@ export class NativePowerAppsBridge {
     } catch (fetchErr) {
       debugWarn(`[bridge] fetch THREW for ${method} ${urlLabel}:`, fetchErr);
       debugLog(`[bridge] fetch THREW for ${method} ${urlLabel} | req body: ${typeof bodyInit === 'string' ? bodyInit.slice(0, 500) : bodyInit != null ? '<non-string body>' : '<no body>'}`);
-      scenario.fail(undefined, {
-        errorName: getSafeErrorName(fetchErr)
-      });
       throw fetchErr;
     }
     const responseHeaders = {};
@@ -252,14 +248,17 @@ export class NativePowerAppsBridge {
       responseHeaders[sdkKey] = value;
     });
     debugLog(`[bridge] ${method} ${urlLabel} → ${response.status}`);
+    const correlationProperties = getHttpCorrelationProperties(response.headers);
     let buffer;
     try {
       buffer = await response.arrayBuffer();
     } catch (readErr) {
       debugWarn(`[bridge] HTTP ${response.status} for ${method} ${urlLabel} | failed to read response body:`, readErr);
-      scenario.fail(undefined, {
+      getAppLogger().trackErrorEvent(HostOperationNames.BridgeHttpRequest, {
+        phase: 'readResponseBody',
         errorName: getSafeErrorName(readErr),
-        httpStatus: response.status
+        httpStatus: response.status,
+        ...correlationProperties
       });
       throw readErr;
     }
@@ -267,14 +266,8 @@ export class NativePowerAppsBridge {
       const bodyText = new TextDecoder().decode(buffer).slice(0, 1000);
       debugWarn(`[bridge] HTTP ${response.status} for ${method} ${urlLabel} | res: ${bodyText}`);
       debugLog(`[bridge] HTTP ${response.status} for ${method} ${urlLabel} | req: ${typeof bodyInit === 'string' ? bodyInit.slice(0, 500) : bodyInit != null ? '<non-string body>' : '<no body>'} | res: ${bodyText}`);
-      scenario.completeWithError({
-        httpStatus: response.status
-      });
-    } else {
-      scenario.complete({
-        httpStatus: response.status
-      });
     }
+    assertSuccessfulHttpStatus(response.status, method);
     return [{
       status: response.status,
       headers: responseHeaders

package/lib/module/bridge/PowerPagesBridge.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import { bridgeHttpClient, getAppLogger, HostOperationNames } from "../telemetry/index.js";
+import { getHttpCorrelationProperties } from '@microsoft/power-apps-native-common/http';
 function toPowerPagesUrl(url) {
   const parsedUrl = new URL(url, window.location.origin);
   if (parsedUrl.origin === window.location.origin && parsedUrl.pathname.startsWith('/_api/')) {
@@ -24,7 +26,7 @@ function toPowerPagesUrl(url) {
 let requestVerificationTokenPromise;
 function getRequestVerificationToken() {
   requestVerificationTokenPromise ??= (async () => {
-    const response = await fetch('/_layout/tokenhtml', {
+    const response = await bridgeHttpClient.request('/_layout/tokenhtml', {
       credentials: 'same-origin'
     });
     if (!response.ok) {
@@ -94,17 +96,34 @@ export class PowerPagesBridge {
     const body = params[1];
     const powerPagesUrl = toPowerPagesUrl(request.url);
     const token = await getRequestVerificationToken();
-    const response = await fetch(powerPagesUrl, {
-      method: request.method,
-      headers: createHeaders(request.headers, token),
-      body: body || undefined,
-      credentials: 'same-origin'
-    });
+    let response;
+    try {
+      response = await bridgeHttpClient.request(powerPagesUrl, {
+        method: request.method,
+        headers: createHeaders(request.headers, token),
+        body: body || undefined,
+        credentials: 'same-origin'
+      });
+    } catch (error) {
+      throw error;
+    }
+    const correlationProperties = getHttpCorrelationProperties(response.headers);
     const responseHeaders = {};
     response.headers.forEach((value, name) => {
       responseHeaders[name === 'content-type' ? 'Content-Type' : name] = value;
     });
-    const responseBody = await response.arrayBuffer();
+    let responseBody;
+    try {
+      responseBody = await response.arrayBuffer();
+    } catch (error) {
+      getAppLogger().trackErrorEvent(HostOperationNames.BridgeHttpRequest, {
+        phase: 'readResponseBody',
+        errorName: error instanceof Error ? error.constructor.name : typeof error,
+        httpStatus: response.status,
+        ...correlationProperties
+      });
+      throw error;
+    }
     if (!response.ok) {
       const responseText = new TextDecoder().decode(responseBody).slice(0, 1000);
       const detail = responseText ? `: ${responseText}` : '';

package/lib/module/bridge/bridgeState.js

@@ -0,0 +1,34 @@
+"use strict";
+
+export function getRequestBodyForMethod(method, body) {
+  const normalizedMethod = method.toUpperCase();
+  return normalizedMethod === 'GET' || normalizedMethod === 'HEAD' ? null : body;
+}
+export function assertSuccessfulHttpStatus(status, method) {
+  if (status >= 200 && status < 300) return;
+  throw new Error(`HTTP ${status} for ${method.toUpperCase()} request`);
+}
+export function updateBridgeOptionsInPlace(current, next) {
+  const connections = current.connections;
+  for (const key of Object.keys(connections)) {
+    if (!(key in next.connections)) delete connections[key];
+  }
+  for (const [key, nextConnection] of Object.entries(next.connections)) {
+    const currentConnection = connections[key];
+    if (currentConnection) {
+      for (const property of Object.keys(currentConnection)) {
+        delete currentConnection[property];
+      }
+      Object.assign(currentConnection, nextConnection);
+    } else {
+      connections[key] = nextConnection;
+    }
+  }
+  const dataSources = current.dataSources;
+  dataSources.splice(0, dataSources.length, ...next.dataSources);
+  return {
+    ...next,
+    connections,
+    dataSources
+  };
+}

package/lib/module/config/babelConfig.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export function createPowerAppsBabelConfig(api, options = {}) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo', ...(options.presets || [])],
+    plugins: [...(options.plugins || []), 'react-native-reanimated/plugin']
+  };
+}

package/lib/module/config/expoConfig.js

@@ -0,0 +1,67 @@
+"use strict";
+
+/**
+ * Branding placeholder used when the app supplies no icon/splash of its own.
+ *
+ * Expo only carves out native branding slots for images it knows about at
+ * prebuild time. Passing nothing means no slot is generated, and the wrap
+ * pipeline then has nothing to overwrite — so customer icons and splash
+ * screens silently never appear in the wrapped app. Always supplying a source
+ * guarantees the slots exist and are replaceable:
+ *   Android — res/mipmap-*\/ic_launcher*.png, res/drawable-*\/splashscreen_logo.png
+ *   iOS     — AppIcon and SplashScreenLogo imagesets
+ */
+const PLACEHOLDER_BRANDING_IMAGE = './assets/adaptive-icon.png';
+export function createPowerAppsExpoConfig(baseConfig, settings, customize = config => config) {
+  const resolvedIconPath = settings.iconPath || PLACEHOLDER_BRANDING_IMAGE;
+  const resolvedSplashPath = settings.splashPath || process.env.APP_SPLASH_PATH || PLACEHOLDER_BRANDING_IMAGE;
+  const icon = {
+    icon: resolvedIconPath
+  };
+  const adaptiveIcon = {
+    adaptiveIcon: {
+      foregroundImage: resolvedIconPath,
+      backgroundColor: '#ffffff'
+    }
+  };
+  return customize({
+    ...baseConfig,
+    ...icon,
+    name: settings.name,
+    slug: settings.slug,
+    version: settings.version,
+    scheme: settings.scheme,
+    userInterfaceStyle: 'automatic',
+    web: {
+      bundler: 'metro',
+      output: 'static'
+    },
+    platforms: ['ios', 'android', 'web'],
+    experiments: {
+      typedRoutes: true
+    },
+    plugins: [...(settings.isDevClient ? ['expo-dev-client'] : []), 'expo-asset', 'expo-audio', 'expo-font', 'expo-image', 'expo-mail-composer', 'expo-router', 'expo-secure-store', 'expo-sharing', 'expo-video', 'expo-web-browser', '@microsoft/power-apps-native-host', '@microsoft/power-apps-native-offline', '@react-native-community/datetimepicker',
+    // Configured explicitly rather than left to Expo's default so prebuild
+    // emits named, resource-table-registered splash assets the wrap pipeline
+    // can overwrite: res/drawable-*/splashscreen_logo.png on Android and the
+    // SplashScreenLogo imageset on iOS.
+    ['expo-splash-screen', {
+      image: resolvedSplashPath,
+      imageWidth: 200,
+      resizeMode: 'contain',
+      backgroundColor: '#ffffff'
+    }]],
+    android: {
+      package: settings.androidPackage,
+      versionCode: settings.versionCode,
+      ...adaptiveIcon
+    },
+    ios: {
+      supportsTablet: true,
+      bundleIdentifier: settings.iosBundleIdentifier,
+      infoPlist: {
+        LSApplicationQueriesSchemes: ['intunemam', 'ms-acompli', 'msauthv2', 'msauthv3']
+      }
+    }
+  });
+}