@microsoft/power-apps-native-host 0.3.0 → 0.4.0

package/{scripts/metro-logger.js → lib/module/config/metroLogger.js}

@@ -1,29 +1,23 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
+"use strict";
 
+import fs from 'node:fs';
+import path from 'node:path';
 const SENSITIVE_LINE_PATTERN = /\b(?:authorization|bearer|client[_-]?secret|password|token|access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|accountkey|sharedaccesskey)\b|[?&](?:sig|se|sp|sv|token|access_token|code|client_secret)=|\b(?:AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{30,}|sk-[A-Za-z0-9]{20,})\b/i;
 const DEFAULT_MAX_ERROR_BODY_BYTES = 256 * 1024;
-
 const stateByRoot = new Map();
-
 function stripAnsi(value) {
   return String(value).replace(/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g, '');
 }
-
-function redactMetroLog(value) {
-  return stripAnsi(value).replace(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g, (line) => {
+export function redactMetroLog(value) {
+  return stripAnsi(value).replace(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g, line => {
     if (!SENSITIVE_LINE_PATTERN.test(line)) return line;
     const ending = line.endsWith('\r\n') ? '\r\n' : line.endsWith('\n') ? '\n' : line.endsWith('\r') ? '\r' : '';
     return `[powernative] [REDACTED_SENSITIVE_LINE]${ending}`;
   });
 }
-
 function toError(value) {
   return value instanceof Error ? value : new Error(String(value));
 }
-
 function writeDiagnostic(state, message) {
   try {
     state.diagnosticWrite(message);
@@ -31,75 +25,73 @@ function writeDiagnostic(state, message) {
     state.diagnosticWriteError = toError(error);
   }
 }
-
 function reportInstrumentationError(state, error, phase) {
   if (state.instrumentationError) return;
   const normalizedError = toError(error);
-  const context = { phase, logPath: state.logPath };
-  state.instrumentationError = { error: normalizedError, context };
-
-  if (typeof state.onError === 'function') {
+  const context = {
+    phase,
+    logPath: state.logPath
+  };
+  state.instrumentationError = {
+    error: normalizedError,
+    context
+  };
+  if (state.onError) {
     try {
       state.onError(normalizedError, context);
       return;
     } catch (callbackError) {
       state.onErrorFailure = toError(callbackError);
-      writeDiagnostic(
-        state,
-        `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}; onError callback also failed: ${state.onErrorFailure.message}\n`,
-      );
+      writeDiagnostic(state, `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}; onError callback also failed: ${state.onErrorFailure.message}\n`);
       return;
     }
   }
-
-  writeDiagnostic(
-    state,
-    `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}\n`,
-  );
+  writeDiagnostic(state, `[powernative] Metro logging instrumentation failed during ${phase}: ${normalizedError.message}\n`);
 }
-
 function createMetroLogState(projectRoot, onError) {
   const root = path.resolve(projectRoot || process.cwd());
   const logDir = path.join(root, '.powernative', 'metro-logs');
   const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const stderrWrite = process.stderr.write.__powerNativeMetroLoggerOriginal || process.stderr.write;
+  const patchedWrite = process.stderr.write;
+  const stderrWrite = patchedWrite.__powerNativeMetroLoggerOriginal || patchedWrite;
   const state = {
     root,
     logDir,
     stamp,
     port: 'unknown',
     logPath: path.join(logDir, `metro-${stamp}-pid-${process.pid}-port-unknown.log`),
-    onError: typeof onError === 'function' ? onError : null,
+    onError: onError || null,
     instrumentationError: null,
-    diagnosticWrite: stderrWrite.bind(process.stderr),
+    diagnosticWrite: message => Reflect.apply(stderrWrite, process.stderr, [message])
   };
   stateByRoot.set(root, state);
   return state;
 }
-
 function getMetroLogState(projectRoot, onError) {
   const root = path.resolve(projectRoot || process.cwd());
   const state = stateByRoot.get(root) || createMetroLogState(root, onError);
-  if (typeof onError === 'function') state.onError = onError;
+  if (onError) state.onError = onError;
   return state;
 }
-
 function appendMetroLog(state, value) {
   try {
-    fs.mkdirSync(state.logDir, { recursive: true });
+    fs.mkdirSync(state.logDir, {
+      recursive: true
+    });
     fs.appendFileSync(state.logPath, redactMetroLog(value));
   } catch (error) {
     reportInstrumentationError(state, error, 'log persistence');
   }
 }
-
 function setMetroLogPort(state, port) {
   if (!Number.isInteger(port) || port <= 0 || String(port) === state.port) return;
   const previousPath = state.logPath;
   state.port = String(port);
   state.logPath = path.join(state.logDir, `metro-${state.stamp}-pid-${process.pid}-port-${state.port}.log`);
   try {
-    fs.mkdirSync(state.logDir, { recursive: true });
+    fs.mkdirSync(state.logDir, {
+      recursive: true
+    });
     if (fs.existsSync(previousPath) && previousPath !== state.logPath) {
       fs.renameSync(previousPath, state.logPath);
     }
@@ -108,34 +100,30 @@ function setMetroLogPort(state, port) {
     reportInstrumentationError(state, error, 'port-tagged log rename');
   }
 }
-
 function extractMetroPort(value) {
   const match = String(value).match(/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]):(\d{2,5})/);
   const port = match ? Number(match[1]) : null;
-  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : null;
+  return Number.isInteger(port) && Number(port) > 0 && Number(port) <= 65535 ? port : null;
 }
-
 function patchStream(stream, key, state) {
   const originalWrite = stream.write;
-  if (typeof originalWrite !== 'function' || originalWrite.__powerNativeMetroLoggerPatched) return;
-
-  function patchedWrite(chunk, encoding, callback) {
+  if (originalWrite.__powerNativeMetroLoggerPatched) return;
+  const patchedWrite = function (chunk, ...args) {
     try {
       const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
       appendMetroLog(state, text);
-      setMetroLogPort(state, extractMetroPort(text));
+      const port = extractMetroPort(text);
+      if (port) setMetroLogPort(state, port);
     } catch (error) {
       reportInstrumentationError(state, error, `${key} capture`);
     }
-    return originalWrite.call(stream, chunk, encoding, callback);
-  }
-
+    return Reflect.apply(originalWrite, stream, [chunk, ...args]);
+  };
   patchedWrite.__powerNativeMetroLoggerPatched = true;
   patchedWrite.__powerNativeMetroLoggerOriginal = originalWrite;
   stream.write = patchedWrite;
 }
-
-function enablePowerNativeMetroLogging(options = {}) {
+export function enablePowerNativeMetroLogging(options = {}) {
   const state = getMetroLogState(options.projectRoot, options.onError);
   try {
     patchStream(process.stdout, 'stdout', state);
@@ -144,70 +132,44 @@ function enablePowerNativeMetroLogging(options = {}) {
   } catch (error) {
     reportInstrumentationError(state, error, 'stream setup');
   }
-  return { logDir: state.logDir, logPath: state.logPath };
+  return {
+    logDir: state.logDir,
+    logPath: state.logPath
+  };
 }
-
-function withPowerNativeMetroLogging(middleware, options = {}) {
-  if (typeof middleware !== 'function') return middleware;
+export function withPowerNativeMetroLogging(middleware, options = {}) {
   const state = getMetroLogState(options.projectRoot, options.onError);
-  const maxBodyBytes = Number.isInteger(options.maxBodyBytes) && options.maxBodyBytes > 0
-    ? options.maxBodyBytes
-    : DEFAULT_MAX_ERROR_BODY_BYTES;
+  const maxBodyBytes = Number.isInteger(options.maxBodyBytes) && Number(options.maxBodyBytes) > 0 ? Number(options.maxBodyBytes) : DEFAULT_MAX_ERROR_BODY_BYTES;
   enablePowerNativeMetroLogging(options);
-
-  return (req, res, next) => {
+  return (request, response, next) => {
     try {
-      setMetroLogPort(state, Number(req.socket && req.socket.localPort));
+      setMetroLogPort(state, Number(request.socket.localPort));
       const chunks = [];
       let capturedBytes = 0;
-      const write = res.write.bind(res);
-      const end = res.end.bind(res);
-
+      const write = response.write.bind(response);
+      const end = response.end.bind(response);
       function captureChunk(chunk, encoding) {
         if (!chunk || capturedBytes >= maxBodyBytes) return;
-        const buf = Buffer.isBuffer(chunk)
-          ? chunk
-          : Buffer.from(String(chunk), typeof encoding === 'string' ? encoding : undefined);
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), typeof encoding === 'string' ? encoding : undefined);
         const remaining = maxBodyBytes - capturedBytes;
-        if (buf.length > remaining) {
-          chunks.push(buf.subarray(0, remaining));
-          capturedBytes = maxBodyBytes;
-          return;
-        }
-        chunks.push(buf);
-        capturedBytes += buf.length;
+        chunks.push(buffer.length > remaining ? buffer.subarray(0, remaining) : buffer);
+        capturedBytes += Math.min(buffer.length, remaining);
       }
-
-      res.write = (chunk, encoding, callback) => {
-        if (typeof encoding === 'function') {
-          callback = encoding;
-          encoding = undefined;
-        }
-        captureChunk(chunk, encoding);
-        return write(chunk, encoding, callback);
+      response.write = (chunk, ...args) => {
+        captureChunk(chunk, args[0]);
+        return Reflect.apply(write, response, [chunk, ...args]);
       };
-
-      res.end = (chunk, encoding, callback) => {
-        if (typeof encoding === 'function') {
-          callback = encoding;
-          encoding = undefined;
-        }
-        captureChunk(chunk, encoding);
-        if (res.statusCode >= 400) {
+      response.end = (chunk, ...args) => {
+        captureChunk(chunk, args[0]);
+        if (response.statusCode >= 400) {
           const body = Buffer.concat(chunks).toString('utf8').slice(0, maxBodyBytes);
-          appendMetroLog(state, `\n[powernative] HTTP ${req.method} ${req.url} -> ${res.statusCode}\n${body}\n`);
+          appendMetroLog(state, `\n[powernative] HTTP ${request.method} ${request.url} -> ${response.statusCode}\n${body}\n`);
         }
-        return end(chunk, encoding, callback);
+        return Reflect.apply(end, response, [chunk, ...args]);
       };
     } catch (error) {
       reportInstrumentationError(state, error, 'HTTP middleware setup');
     }
-    return middleware(req, res, next);
+    return middleware(request, response, next);
   };
-}
-
-module.exports = {
-  enablePowerNativeMetroLogging,
-  redactMetroLog,
-  withPowerNativeMetroLogging,
-};
+}

package/lib/module/config/tamaguiConfig.js

@@ -0,0 +1,93 @@
+"use strict";
+
+import { createTamagui } from '@tamagui/core';
+import { defaultConfig } from '@tamagui/config/v5';
+import { animations } from '@tamagui/config/v5-rn';
+function parseColorChannels(color) {
+  const hexMatch = color.match(/^#([\da-f]{3}|[\da-f]{6})$/i);
+  if (hexMatch) {
+    const hex = hexMatch[1].length === 3 ? [...hexMatch[1]].map(value => `${value}${value}`).join('') : hexMatch[1];
+    return [0, 2, 4].map(offset => Number.parseInt(hex.slice(offset, offset + 2), 16) / 255);
+  }
+  const rgbMatch = color.match(/^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)$/i);
+  if (rgbMatch) {
+    const values = rgbMatch.slice(1, 4).map(Number);
+    if (values.some(value => !Number.isFinite(value) || value < 0 || value > 255)) return null;
+    const alpha = rgbMatch[4] === undefined ? 1 : Number(rgbMatch[4]);
+    if (!Number.isFinite(alpha) || alpha !== 1) return null;
+    return values.map(value => value / 255);
+  }
+  const hslMatch = color.match(/^hsla?\(\s*([-\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%(?:\s*,\s*([\d.]+))?\s*\)$/i);
+  if (!hslMatch) return null;
+  const hsl = hslMatch.slice(1, 4).map(Number);
+  if (hsl.some(value => !Number.isFinite(value))) return null;
+  const alpha = hslMatch[4] === undefined ? 1 : Number(hslMatch[4]);
+  if (!Number.isFinite(alpha) || alpha !== 1) return null;
+  const hue = (hsl[0] % 360 + 360) % 360;
+  const saturation = hsl[1] / 100;
+  const lightness = hsl[2] / 100;
+  if (saturation < 0 || saturation > 1 || lightness < 0 || lightness > 1) return null;
+  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  const intermediate = chroma * (1 - Math.abs(hue / 60 % 2 - 1));
+  const offset = lightness - chroma / 2;
+  const segment = Math.floor(hue / 60);
+  const rgb = [[chroma, intermediate, 0], [intermediate, chroma, 0], [0, chroma, intermediate], [0, intermediate, chroma], [intermediate, 0, chroma], [chroma, 0, intermediate]][segment];
+  return rgb.map(value => value + offset);
+}
+function readableForeground(background, fallback) {
+  if (!background) return fallback;
+  const channels = parseColorChannels(background);
+  if (!channels) return fallback;
+  const linearChannels = channels.map(value => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4);
+  const luminance = 0.2126 * linearChannels[0] + 0.7152 * linearChannels[1] + 0.0722 * linearChannels[2];
+  return luminance > 0.179 ? '#000000' : '#ffffff';
+}
+export function withPowerAppsSemanticAliases(theme, brand = {}) {
+  return {
+    ...theme,
+    surface0: brand.bg ?? theme.background,
+    surface1: brand.surface ?? theme.color3,
+    surface2: theme.color4,
+    surface3: brand.border ?? theme.color5,
+    mediaSurface: theme.color4,
+    accentDeep: brand.primary ?? theme.blue11,
+    accentBase: brand.primary ?? theme.blue10,
+    accentSoft: brand.accent ?? theme.blue3,
+    accentOnAccent: brand.onPrimary ?? readableForeground(brand.primary ?? theme.blue10, theme.color1),
+    text0: brand.text ?? theme.color12,
+    text1: brand.textMuted ?? theme.color11,
+    text2: theme.color10,
+    text3: theme.color9,
+    statusComplete: brand.statusSuccess ?? theme.green11,
+    statusCompleteBg: theme.green3,
+    statusPending: brand.statusWarning ?? theme.yellow11,
+    statusPendingBg: theme.yellow3,
+    statusOverdue: brand.statusDanger ?? theme.red11,
+    statusOverdueBg: theme.red3,
+    statusInProgress: brand.statusInfo ?? theme.blue11,
+    statusInProgressBg: theme.blue3,
+    statusDraft: theme.color10,
+    statusDraftBg: theme.color3,
+    statusCancelled: theme.red11,
+    statusCancelledBg: theme.red3
+  };
+}
+const powerAppsTamaguiDefaults = {
+  ...defaultConfig,
+  animations,
+  themes: {
+    ...defaultConfig.themes,
+    light: withPowerAppsSemanticAliases(defaultConfig.themes.light),
+    dark: withPowerAppsSemanticAliases(defaultConfig.themes.dark)
+  },
+  fonts: {
+    ...defaultConfig.fonts,
+    mono: defaultConfig.fonts.body
+  }
+};
+export function createPowerAppsTamaguiConfig(overrides = {}) {
+  return createTamagui({
+    ...powerAppsTamaguiDefaults,
+    ...overrides
+  });
+}

package/lib/module/connections/resolveConnections.js

@@ -57,6 +57,7 @@ const API_VERSION = '1';
  */
 export async function resolveViaStaticRefs({
   connectionReferences,
+  hasDataverse,
   schemaMap,
   environmentId,
   region,
@@ -94,8 +95,8 @@ export async function resolveViaStaticRefs({
     Authorization: `Bearer ${token}`
   };
 
-  // Fetch Dataverse instanceUrl and all connection instances in parallel.
-  const [instanceUrl, ...connResults] = await Promise.all([fetchInstanceUrl(environmentId, region, acquireToken, token), ...Object.entries(directConnectionReferences).map(async ([localRefId, ref]) => {
+  // Fetch the Dataverse instanceUrl only when the app uses Dataverse.
+  const [instanceUrl, ...connResults] = await Promise.all([hasDataverse ? fetchInstanceUrl(environmentId, region, acquireToken, token) : Promise.resolve(undefined), ...Object.entries(directConnectionReferences).map(async ([localRefId, ref]) => {
     const apiId = normalizeApiId(ref.id);
     const schema = schemaByApiId[apiId];
     if (!schema) {

package/lib/module/connections/useConnectionRefs.js

@@ -64,6 +64,7 @@ export function useConnectionRefs({
   environmentId,
   region = 'prod',
   connectionReferences,
+  hasDataverse,
   schemaMap,
   onDisambiguationNeeded,
   onMissingConnection,
@@ -242,6 +243,7 @@ export function useConnectionRefs({
         }
         result = await resolveViaStaticRefs({
           connectionReferences,
+          hasDataverse,
           schemaMap,
           environmentId,
           region,
@@ -311,7 +313,7 @@ export function useConnectionRefs({
       if (retryTimer) clearTimeout(retryTimer);
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [isSignedIn, retryTick, appId, environmentId, region, connectionReferences, schemaMap, isvClientId]);
+  }, [isSignedIn, retryTick, appId, environmentId, region, connectionReferences, hasDataverse, schemaMap, isvClientId]);
   return {
     connectionRefs,
     isReady,

package/lib/module/index.js

@@ -6,6 +6,10 @@
  * 
  */
 
+// Side-effect: installs the wrap-injected customer asset resolver before any
+// screen renders. No-op on web/dev and in any base app without the native
+// module, so importing the package root is always safe.
+import '@microsoft/power-apps-native-assets';
 export { NativePowerAppsBridge } from "./bridge/NativePowerAppsBridge.js";
 export { PowerPagesBridge, setupPowerPagesHost } from "./bridge/PowerPagesBridge.js";
 export { buildConnectionReferences } from "./bridge/NativePowerAppsBridge.js";
@@ -44,6 +48,6 @@ export { isDevPlayer } from "./utils/isDevPlayer.js";
 export { base64ToDataverseUploadFile, base64ToUint8Array, createDataverseUploadFile } from "./utils/dataverseUtils.js";
 
 // ── Telemetry ─────────────────────────────────────────────────────────────────
-export { getAppLogger, configureAppLogger, getCustomerTelemetryLogger, HostOperationNames } from "./telemetry/index.js";
+export { getAppLogger, configureAppLogger, getCustomEventsLogger, HostOperationNames } from "./telemetry/index.js";
 // ── Error boundary ────────────────────────────────────────────────────────────
 export { ErrorBoundary } from "./ErrorBoundary.js";

package/lib/module/offline/useOfflineIntegrationWithStartupGate.js

@@ -4,6 +4,7 @@ import { useCallback, useEffect, useMemo } from 'react';
 import { useQueryClient } from '@tanstack/react-query';
 import { getAppLogger } from '@microsoft/power-apps-native-common';
 import { fetchInstanceUrl } from "../platform/DataverseGlobalDiscoveryApi.js";
+import { hasDataverseDatabaseReferences } from "../platform/DataverseDataSources.js";
 import { HostOperationNames } from "../telemetry/index.js";
 import { createOfflineHostActivationCallbacks, resolveSdkMountDecision } from "./createOfflineHostActivationCallbacks.js";
 import { useOfflineIntegration } from './useOfflineIntegration';
@@ -15,7 +16,8 @@ export function useOfflineIntegrationWithStartupGate({
   isAuthReady
 }) {
   const queryClient = useQueryClient();
-  const resolveInstanceUrl = useCallback(async (environmentId, region, acqToken) => (await fetchInstanceUrl(environmentId, region, acqToken)) ?? null, []);
+  const hasDataverse = hasDataverseDatabaseReferences(powerConfig.databaseReferences);
+  const resolveInstanceUrl = useCallback(async (environmentId, region, acqToken) => hasDataverse ? (await fetchInstanceUrl(environmentId, region, acqToken)) ?? null : null, [hasDataverse]);
   const hostActivationCallbacks = useMemo(() => createOfflineHostActivationCallbacks(queryClient), [queryClient]);
   const offline = useOfflineIntegration({
     powerConfig,

package/lib/module/platform/DataverseDataSources.js

@@ -1,5 +1,8 @@
 "use strict";
 
+export function hasDataverseDatabaseReferences(databaseReferences) {
+  return Object.keys(databaseReferences ?? {}).length > 0;
+}
 export function buildCdsDataSources(databaseReferences, dataverseOrgUrl) {
   return Object.values(databaseReferences).flatMap(databaseReference => Object.values(databaseReference.dataSources ?? {}).map(dataSource => ({
     runtimeUrl: dataverseOrgUrl ? `${dataverseOrgUrl}/api/data/v9.0/` : '',

package/lib/module/platform/DataverseGlobalDiscoveryApi.js

@@ -1,8 +1,40 @@
 "use strict";
 
 import { getHttpCorrelationProperties } from '@microsoft/power-apps-native-common/http';
+import * as SecureStore from 'expo-secure-store';
 import { getAppLogger, HostOperationNames, platformHttpClient } from "../telemetry/index.js";
 import { buildGlobalDiscoveryUrl, globalDiscoveryScope } from "./GlobalDiscovery.js";
+const INSTANCE_URL_CACHE_KEY_PREFIX = 'microsoft.power-apps-native-host.instance-url.v1';
+const INSTANCE_URL_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+function getInstanceUrlCacheKey(environmentId, region) {
+  return `${INSTANCE_URL_CACHE_KEY_PREFIX}.${region.toLowerCase()}.${environmentId.toLowerCase()}`;
+}
+async function getCachedInstanceUrl(environmentId, region) {
+  try {
+    const cachedValue = await SecureStore.getItemAsync(getInstanceUrlCacheKey(environmentId, region));
+    if (!cachedValue) {
+      return null;
+    }
+    const entry = JSON.parse(cachedValue);
+    if (typeof entry.instanceUrl !== 'string' || typeof entry.expiresAt !== 'number' || entry.expiresAt <= Date.now()) {
+      return null;
+    }
+    return entry.instanceUrl;
+  } catch {
+    return null;
+  }
+}
+async function cacheInstanceUrl(environmentId, region, instanceUrl) {
+  try {
+    const entry = {
+      instanceUrl,
+      expiresAt: Date.now() + INSTANCE_URL_CACHE_TTL_MS
+    };
+    await SecureStore.setItemAsync(getInstanceUrlCacheKey(environmentId, region), JSON.stringify(entry));
+  } catch {
+    // SecureStore may be unavailable (for example, on web); discovery still succeeds.
+  }
+}
 function getSafeErrorName(error) {
   return error instanceof Error ? error.constructor.name : typeof error;
 }
@@ -14,6 +46,14 @@ export async function fetchInstanceUrl(environmentId, region, acquireToken, _bea
     region
   });
   try {
+    const cachedInstanceUrl = await getCachedInstanceUrl(environmentId, region);
+    if (cachedInstanceUrl) {
+      scenario.complete({
+        hasInstanceUrl: true,
+        cacheHit: true
+      });
+      return cachedInstanceUrl;
+    }
     const url = buildGlobalDiscoveryUrl(environmentId, region);
     const token = await acquireToken([globalDiscoveryScope(region)]);
     if (!token) {
@@ -31,8 +71,12 @@ export async function fetchInstanceUrl(environmentId, region, acquireToken, _bea
     }
     const result = await response.json();
     const instanceUrl = result.value?.find(instance => instance.EnvironmentId?.toLowerCase() === environmentId.toLowerCase())?.ApiUrl;
+    if (instanceUrl) {
+      await cacheInstanceUrl(environmentId, region, instanceUrl);
+    }
     scenario.complete({
       hasInstanceUrl: instanceUrl !== undefined,
+      cacheHit: false,
       ...getHttpCorrelationProperties(response.headers)
     });
     return instanceUrl;

package/lib/module/provider/PowerAppsHostProvider.js

@@ -35,7 +35,7 @@ import { SafeAreaProvider } from 'react-native-safe-area-context';
 import { setupNativeHost } from "../bridge/setupNativeHost.js";
 import { buildConnectionReferences } from "../bridge/NativePowerAppsBridge.js";
 import { useConnectionRefs } from "../connections/useConnectionRefs.js";
-import { buildCdsDataSources } from "../platform/DataverseDataSources.js";
+import { buildCdsDataSources, hasDataverseDatabaseReferences } from "../platform/DataverseDataSources.js";
 import { powerPlatformScope } from "../platform/PowerPlatformEnvironmentApi.js";
 import { ConnectionSetupScreen } from "../connections/ConnectionSetupScreen.js";
 import { buildConnectionResolutionKey } from "../connections/types.js";
@@ -146,6 +146,7 @@ export function PowerAppsHostProvider({
     environmentId,
     region,
     connectionReferences,
+    hasDataverse: hasDataverseDatabaseReferences(databaseReferences),
     schemaMap,
     onDisambiguationNeeded,
     isvClientId

package/lib/module/provider/PowerAppsProvider.js

@@ -42,8 +42,9 @@ import { powerPlatformScope } from "../platform/PowerPlatformEnvironmentApi.js";
 import { ThemeProvider } from "../theme/ThemeProvider.js";
 import { ErrorBoundary } from "../ErrorBoundary.js";
 import { isDevPlayer } from "../utils/isDevPlayer.js";
+import * as Application from 'expo-application';
 import Constants from 'expo-constants';
-import { ApplicationInsightsTelemetryProvider, configureAppLogger, configureCustomerTelemetryLogger, getAppLogger, Logger, OneDsTelemetryProvider, resolveDeviceId, resolveTelemetryLocation, regionToClusterCategory, suppressKnownWarnings } from '@microsoft/power-apps-native-common';
+import { ApplicationInsightsTelemetryProvider, configureAppLogger, configureCustomEventsLogger, getAppLogger, Logger, OneDsTelemetryProvider, resolveDeviceId, resolveTelemetryLocation, regionToClusterCategory, suppressKnownWarnings } from '@microsoft/power-apps-native-common';
 suppressKnownWarnings();
 import { createHostQueryClient } from "../offline/createOfflineHostActivationCallbacks.js";
 import { useOfflineIntegrationWithStartupGate } from '../offline/useOfflineIntegrationWithStartupGate';
@@ -226,6 +227,7 @@ function InnerProviders({
  * root layout.
  */
 export function PowerAppsProvider({
+  appConfig,
   msalConfig,
   intuneConfig,
   powerConfig,
@@ -243,7 +245,8 @@ export function PowerAppsProvider({
   onConnectionConsentDeclined,
   appName,
   logger: loggerProp,
-  showSessionDetailsOnSwipe = true,
+  showSessionDetailsOnLongPress,
+  showSessionDetailsOnSwipe,
   appInsightsConfig,
   offlineProfile,
   children
@@ -252,15 +255,17 @@ export function PowerAppsProvider({
   // is stable (loggerProp is an object reference; re-running on every render
   // would reconfigure and leak the previous provider).
   const loggerPropRef = useRef(loggerProp);
-  const appInsightsConfigRef = useRef(appInsightsConfig ?? readAppInsightsConfig(Constants.expoConfig?.extra?.appInsightsConfig));
+  const appInsightsConfigRef = useRef(appInsightsConfig ?? readAppInsightsConfig(appConfig?.expo?.extra?.appInsightsConfig ?? Constants.expoConfig?.extra?.appInsightsConfig));
   const [offlineTelemetryEnabled, setOfflineTelemetryEnabled] = useState();
   const missingClientIdInDevPlayer = Platform.OS !== 'web' && isDevPlayer && !hasConfiguredValue(msalConfig.clientId) && requiresPowerPlatformAuth(powerConfig);
-  const missingAppId = !isDevPlayer && !hasConfiguredValue(powerConfig.appId);
+  const missingAppId = Platform.OS !== 'web' && !isDevPlayer && !hasConfiguredValue(powerConfig.appId);
   const missingEnvironmentId = !isDevPlayer && !hasConfiguredValue(powerConfig.environmentId);
   const appId = typeof powerConfig.appId === 'string' ? powerConfig.appId.trim() : '';
-  const bundleId = Platform.OS === 'ios' ? Constants.expoConfig?.ios?.bundleIdentifier : Platform.OS === 'android' ? Constants.expoConfig?.android?.package : undefined;
+  const configuredBundleId = Platform.OS === 'ios' ? Constants.expoConfig?.ios?.bundleIdentifier : Platform.OS === 'android' ? Constants.expoConfig?.android?.package : undefined;
+  const bundleId = Platform.OS === 'ios' || Platform.OS === 'android' ? Application.applicationId ?? configuredBundleId : undefined;
   const appInstanceId = Constants.expoConfig?.extra?.telemetry?.appInstanceId;
   const skillCorrelationId = typeof appInstanceId === 'string' ? appInstanceId.trim() : '';
+  const sessionDetailsGestureEnabled = showSessionDetailsOnLongPress ?? showSessionDetailsOnSwipe ?? true;
   const requiredAuthScopes = useMemo(() => [powerPlatformScope(powerConfig.region ?? 'prod')], [powerConfig.region]);
   const queryClient = useMemo(() => createHostQueryClient(), []);
 
@@ -270,9 +275,9 @@ export function PowerAppsProvider({
   // silent no-op Logger, so any telemetry emitted before the first commit is
   // silently dropped rather than crashing.
   useEffect(() => {
-    // Customer telemetry is a no-op until a valid Application Insights
+    // Custom events are a no-op until a valid Application Insights
     // provider is configured below.
-    configureCustomerTelemetryLogger(new Logger());
+    configureCustomEventsLogger(new Logger());
     const lp = loggerPropRef.current;
     if (lp === null) {
       // Explicit opt-out — replace with a silent no-op Logger.
@@ -318,7 +323,7 @@ export function PowerAppsProvider({
               sessionId: oneDsProvider.sessionId
             });
             providers.push(customerProvider);
-            configureCustomerTelemetryLogger(new Logger({
+            configureCustomEventsLogger(new Logger({
               providers: [customerProvider]
             }));
             appInsightsEnabled = true;
@@ -380,7 +385,7 @@ export function PowerAppsProvider({
               swipeDirection: "horizontal",
               duration: 3000,
               children: [/*#__PURE__*/_jsx(SessionDetailsGesture, {
-                enabled: showSessionDetailsOnSwipe,
+                enabled: sessionDetailsGestureEnabled,
                 appName: appName ?? Constants.expoConfig?.name ?? 'Power Apps',
                 appId: appId || undefined,
                 environmentId: powerConfig.environmentId,

package/lib/module/provider/SessionDetailsGesture.js

@@ -6,7 +6,6 @@ import * as Clipboard from 'expo-clipboard';
 import { Gesture, GestureDetector } from 'react-native-gesture-handler';
 import { getAppLogger } from "../telemetry/index.js";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-const SWIPE_DISTANCE = 80;
 export function SessionDetailsGesture({
   enabled,
   appName,
@@ -24,14 +23,7 @@ export function SessionDetailsGesture({
     setCopied(false);
     setVisible(true);
   }, []);
-  const gesture = useMemo(() => Gesture.Pan().enabled(enabled && Platform.OS !== 'web').minPointers(3).maxPointers(3).runOnJS(true).onEnd(({
-    translationX,
-    translationY
-  }) => {
-    if (translationY >= SWIPE_DISTANCE && translationY > Math.abs(translationX)) {
-      showSessionDetails();
-    }
-  }), [enabled, showSessionDetails]);
+  const gesture = useMemo(() => Gesture.LongPress().enabled(enabled && Platform.OS !== 'web').numberOfPointers(3).runOnJS(true).onStart(showSessionDetails), [enabled, showSessionDetails]);
   const close = useCallback(() => setVisible(false), []);
   const copySessionId = useCallback(async () => {
     if (!sessionId) return;

package/lib/module/telemetry/index.js

@@ -12,7 +12,7 @@
 
 import { HttpClient } from '@microsoft/power-apps-native-common/http';
 import { isDebugLoggingEnabled } from "../logger.js";
-export { getAppLogger, configureAppLogger, getCustomerTelemetryLogger } from '@microsoft/power-apps-native-common';
+export { getAppLogger, configureAppLogger, getCustomEventsLogger } from '@microsoft/power-apps-native-common';
 /**
  * Canonical operation names for host package telemetry.
  * Follow the `PowerAppsHost.<Subsystem>.<Action>` convention so events are