@microsoft/power-apps-native-host 0.2.22

package/lib/typescript/module/provider/PowerAppsProvider.d.ts

@@ -0,0 +1,148 @@
+/*!
+ * power-apps-native-host — PowerAppsProvider
+ *
+ * A single provider that composes all infrastructure required to run a
+ * Power Apps canvas app inside an Expo shell:
+ *
+ *   GestureHandlerRootView
+ *   └── TamaguiProvider  (defaults to @tamagui/config/v3)
+ *       └── PortalProvider  (required by ToastViewport)
+ *           └── ToastProvider + ToastViewport
+ *               └── QueryClientProvider  (own QueryClient, wired to NetInfo + AppState)
+ *                   └── AuthProvider
+ *                       └── PowerAppsHostProvider  (connected via useAuth)
+ *                           └── children
+ *
+ * Usage:
+ *
+ *   <PowerAppsProvider
+ *     msalConfig={authConfig.msal}
+ *     powerConfig={powerConfig}
+ *     schemaMap={schemaMap}
+ *   >
+ *     <StatusBar style="auto" />
+ *     <Slot />
+ *   </PowerAppsProvider>
+ */
+import React from 'react';
+import { createTamagui } from '@tamagui/core';
+import type { AuthProviderProps } from '../auth/AuthContext.js';
+import type { PowerAppsHostProviderProps } from './PowerAppsHostProvider.js';
+import type { ConnectorSchema } from '../platform/useConnectionRefs.js';
+import type { DatabaseReference } from '../platform/PowerPlatformEnvironmentApi.js';
+import type { OnDisambiguationNeeded } from '../connections/types.js';
+import type { ThemeTokens } from '../theme/tokens.js';
+import type { ILogger } from '@microsoft/power-apps-native-common';
+/** Shape of power.config.json consumed by the provider. */
+export interface PowerConfig {
+    /**
+     * PowerApps app GUID written by `pac wrap` / the publish pipeline.
+     * When set, the host fetches connection references from the PowerApps RP
+     * `/apps/{appId}/launch` endpoint at runtime instead of reading the static
+     * `connectionReferences` object below.  Leave `null` (or omit) during local
+     * development — the static `connectionReferences` will be used as a fallback.
+     */
+    appId?: string | null;
+    environmentId?: string;
+    region?: string;
+    /**
+     * BAP environment `location` value (`environment.properties.location` from the
+     * Get Environments API). EU locations — `"europe"`, `"unitedkingdom"`,
+     * `"france"`, `"germany"`, `"italy"`, `"poland"`, `"norway"`, `"sweden"`,
+     * `"switzerland"` — route telemetry to the EU 1DS collector.
+     * Omit for the default global collector.
+     */
+    geoRegion?: string;
+    connectionReferences?: Record<string, {
+        id: string;
+        dataSources: string[];
+    }>;
+    databaseReferences?: Record<string, DatabaseReference>;
+    /**
+     * Allow additional keys — the offline SDK reads arbitrary fields from
+     * powerConfig. NOTE: offline activation is configured via the app's
+     * `offline-profile.json` (embedded into the Expo manifest as
+     * `extra.__offlineProfile`), NOT via a `powerConfig` field.
+     */
+    [key: string]: unknown;
+}
+type TamaguiConfig = ReturnType<typeof createTamagui>;
+export interface PowerAppsProviderProps {
+    /** MSAL configuration from auth.config.json (msal section). */
+    msalConfig: AuthProviderProps['msalConfig'];
+    /** Intune MAM configuration. Defaults to enabled in release builds. */
+    intuneConfig?: AuthProviderProps['intuneConfig'];
+    /** Contents of power.config.json. */
+    powerConfig: PowerConfig;
+    /**
+     * Connector schema map keyed by data source name.
+     * Generated automatically by generate-connector-schemas.
+     */
+    schemaMap: Record<string, ConnectorSchema>;
+    /**
+     * Tamagui design-system config.
+     * Defaults to the standard @tamagui/config/v3 preset.
+     */
+    tamaguiConfig?: TamaguiConfig;
+    /** Tamagui default colour theme. @default 'light' */
+    defaultTheme?: string;
+    /**
+     * Light-mode theme tokens for the built-in ThemeProvider.
+     * Defaults to the Power Platform green light palette.
+     * Pass a ThemeTokens object built from brand/tokens.ts to apply your brand.
+     */
+    theme?: ThemeTokens;
+    /**
+     * Dark-mode theme tokens for the built-in ThemeProvider.
+     * Defaults to the Power Platform green dark palette.
+     */
+    darkTheme?: ThemeTokens;
+    /**
+     * When `true`, the ThemeProvider automatically switches between `theme` and
+     * `darkTheme` based on the device colour scheme. @default true
+     */
+    followSystemTheme?: boolean;
+    /** See PowerAppsHostProviderProps.renderOAuthWebView. */
+    renderOAuthWebView?: PowerAppsHostProviderProps['renderOAuthWebView'];
+    /** See PowerAppsHostProviderProps.onDisambiguationNeeded. */
+    onDisambiguationNeeded?: OnDisambiguationNeeded;
+    /**
+     * App name used as `clientType` in the auto-wired 1DS telemetry provider.
+     * Appears in Kusto as the `clientType` column — use a stable
+     * `<Product><Variant>` string (e.g. `'PowerAppsDevPlayer'`).
+     * Ignored when `logger` is provided or `null`.
+     */
+    appName?: string;
+    /**
+     * Logger to use for host-package telemetry (auth, HTTP, platform APIs).
+     *
+     * - Omit (default): a `Logger` wired to `OneDsTelemetryProvider` (1DS JS)
+     *   is auto-created. `clusterCategory` is derived from `powerConfig.region`
+     *   (falls back to `'dev'`). This is the recommended path for all apps.
+     * - Pass an `ILogger` instance: that logger is used as-is, giving full
+     *   control over providers and severity.
+     * - Pass `null`: telemetry is explicitly disabled (opt-out). The host
+     *   logger becomes a no-op regardless of build variant.
+     */
+    logger?: ILogger | null;
+    /**
+     * Offline profile JSON — optional override.
+     * Primary source: SDK config plugin embeds offline-profile.json into the app
+     * manifest at prebuild time (read via expo-constants). This prop is only needed
+     * if you want to pass the profile programmatically (e.g., tests).
+     */
+    offlineProfile?: Record<string, unknown>;
+    children: React.ReactNode;
+}
+/**
+ * Top-level provider for Power Apps canvas apps running inside an Expo shell.
+ *
+ * Composes GestureHandlerRootView, TamaguiProvider, ToastProvider,
+ * QueryClientProvider, AuthProvider, and PowerAppsHostProvider into a single
+ * component, eliminating all provider boilerplate from the consuming app's
+ * root layout.
+ */
+export declare function PowerAppsProvider({ msalConfig, intuneConfig, powerConfig, schemaMap, tamaguiConfig, // override with app's tamagui.config.ts
+defaultTheme, theme, darkTheme, followSystemTheme, renderOAuthWebView, onDisambiguationNeeded, appName, logger: loggerProp, offlineProfile, children, }: PowerAppsProviderProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=PowerAppsProvider.d.ts.map

package/lib/typescript/module/telemetry/index.d.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *
+ * power-apps-native-host — package telemetry
+ *
+ * The shared logger singleton lives in `@microsoft/power-apps-native-common`
+ * (`getAppLogger` / `configureAppLogger`). This module re-exports those
+ * alongside the canonical host operation-name constants.
+ */
+export { getAppLogger, configureAppLogger } from '@microsoft/power-apps-native-common';
+/**
+ * Canonical operation names for host package telemetry.
+ * Follow the `PowerAppsHost.<Subsystem>.<Action>` convention so events are
+ * filterable in Kusto by prefix.
+ */
+export declare const HostOperationNames: {
+    /** MSAL PublicClientApplication.init() + initial account resolution. */
+    readonly AuthInit: "PowerAppsHost.Auth.Init";
+    /** Interactive sign-in (acquireToken interactive). */
+    readonly AuthSignIn: "PowerAppsHost.Auth.SignIn";
+    /** Sign-out (token cache clear + broker logout). */
+    readonly AuthSignOut: "PowerAppsHost.Auth.SignOut";
+    /** Silent token acquisition. Recorded only on failure. */
+    readonly AuthAcquireTokenSilentFailed: "PowerAppsHost.Auth.AcquireTokenSilent.Failed";
+    /** Intune MAM enrollment after sign-in. */
+    readonly AuthIntuneEnroll: "PowerAppsHost.Auth.Intune.Enroll";
+    /** Intune MAM unenrollment during sign-out. */
+    readonly AuthIntuneUnenroll: "PowerAppsHost.Auth.Intune.Unenroll";
+    /** SDK-originated HTTP request relayed through NativePowerAppsBridge. */
+    readonly BridgeHttpRequest: "PowerAppsHost.Bridge.HttpRequest";
+    /** Plugin call forwarded through NativePowerAppsBridge (verbose; also used for unhandled). */
+    readonly BridgeUnhandledPlugin: "PowerAppsHost.Bridge.PluginCall";
+    /** Connector/Dataverse token acquisition for the bridge. Recorded only on failure. */
+    readonly BridgeTokenAcquireFailed: "PowerAppsHost.Bridge.TokenAcquire.Failed";
+    /** Top-level React error boundary caught an unhandled JS error. */
+    readonly RuntimeUnhandledJsError: "PowerAppsHost.Runtime.UnhandledJsError";
+    /** Resolve Dataverse instanceUrl from Power Platform environment API. */
+    readonly PlatformFetchInstanceUrl: "PowerAppsHost.Platform.FetchInstanceUrl";
+    /** useConnectionRefs failed to resolve connections (recoverable). Recorded only on failure. */
+    readonly PlatformLoadConnectionsFailed: "PowerAppsHost.Platform.LoadConnections.Failed";
+    /** Create a new Power Platform connection. */
+    readonly PlatformCreateConnection: "PowerAppsHost.Platform.CreateConnection";
+    /** Resolve app connection references for the current launch. */
+    readonly PlatformResolveConnectionRefs: "PowerAppsHost.Platform.ResolveConnectionRefs";
+    /** Grant this app access to a Power Platform connection ACL. */
+    readonly PlatformConnectionAclGrant: "PowerAppsHost.Platform.ConnectionAclGrant";
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/theme/ThemeProvider.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ThemeProvider — distributes {@link ThemeTokens} through the component tree.
+ *
+ * `PowerAppsProvider` mounts this automatically. Use directly only when
+ * composing providers manually.
+ */
+import React from 'react';
+import { type ThemeTokens } from './tokens.js';
+export interface ThemeControl {
+    setTheme: (tokens: ThemeTokens) => void;
+    resetTheme: () => void;
+}
+export interface ThemeProviderProps {
+    theme?: ThemeTokens;
+    darkTheme?: ThemeTokens;
+    /** @default true */
+    followSystem?: boolean;
+    children: React.ReactNode;
+}
+export declare function ThemeProvider({ theme, darkTheme, followSystem, children, }: ThemeProviderProps): React.JSX.Element;
+/** Returns current {@link ThemeTokens} from the nearest ThemeProvider. */
+export declare function useThemeTokens(): ThemeTokens;
+/**
+ * Returns `{ setTheme, resetTheme }` for imperative theme overrides.
+ * Stable reference — does not re-render consumers on theme change.
+ */
+export declare function useThemeControl(): ThemeControl;
+export type { ThemeTokens } from './tokens.js';
+export { lightTheme, darkTheme } from './tokens.js';
+//# sourceMappingURL=ThemeProvider.d.ts.map

package/lib/typescript/module/theme/tokens.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Theme token schema and built-in palettes for power-apps-native-host.
+ *
+ * Pass a custom {@link ThemeTokens} object to `PowerAppsProvider` to override
+ * the default Microsoft blue palette.
+ */
+export interface ThemeTokens {
+    surface0: string;
+    surface1: string;
+    surface2: string;
+    surface3: string;
+    surface4: string;
+    text0: string;
+    text1: string;
+    text2: string;
+    text3: string;
+    accentDeep: string;
+    accentBase: string;
+    accentSoft: string;
+    accentOnAccent: string;
+    isDark: boolean;
+}
+/** Microsoft blue light palette (default). */
+export declare const lightTheme: ThemeTokens;
+/** Microsoft blue dark palette (default). */
+export declare const darkTheme: ThemeTokens;
+//# sourceMappingURL=tokens.d.ts.map

package/lib/typescript/module/utils/dataverseUtils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Utilities for reading local file:// URIs and converting them into the binary
+ * format expected by the Dataverse upload endpoint via NativePowerAppsBridge.
+ *
+ * Background:
+ *  - `fetch('file://')` fails silently on Android.
+ *  - `fetch('data:...')` throws "Network request failed" on Android.
+ *  - `new Blob([Uint8Array])` crashes Hermes ("ArrayBufferView not supported").
+ *  - NativePowerAppsBridge accepts `Uint8Array` and extracts `.buffer` as the
+ *    fetch body, which React Native sends as raw bytes correctly.
+ *
+ * Solution: read via `readAsStringAsync` (base64) → `atob` → `Uint8Array`.
+ */
+/**
+ * Read a local `file://` URI and return its contents as a `Uint8Array`.
+ * Safe on both Android and iOS.
+ */
+export declare function readFileAsUint8Array(uri: string): Promise<Uint8Array>;
+/**
+ * Detect the image MIME type from the first bytes of a base64-encoded string.
+ * Returns 'image/jpeg' as a safe default.
+ */
+export declare function detectImageMime(base64: string): string;
+/** Convert a base64 string into bytes suitable for Dataverse binary upload APIs. */
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+/**
+ * Create a lightweight File-compatible object for generated Dataverse upload methods.
+ * React Native does not consistently provide a browser File implementation, but the
+ * generated services only require `name` and `arrayBuffer()`.
+ */
+export declare function createDataverseUploadFile(name: string, mimeType: string, bytes: Uint8Array): File;
+/** Create a File-compatible image object from Dataverse-style base64 image content. */
+export declare function base64ToDataverseUploadFile(base64: string, name?: string): File;
+/**
+ * Build a `data:<mime>;base64,<data>` URI from a raw base64 string returned
+ * by Dataverse for an image column.
+ */
+export declare function base64ToDataUri(base64: string): string;
+//# sourceMappingURL=dataverseUtils.d.ts.map

package/lib/typescript/module/utils/isDevPlayer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * True when the JS bundle is running inside the Power Apps Dev Player shell.
+ *
+ * Two signals are combined to cover both execution paths:
+ *
+ * 1. `Constants.expoConfig.extra.isDevPlayer` — set in apps/dev-player/app.config.js.
+ *    Fires when the dev-player's **own** JS bundle is active (e.g. the launcher screen).
+ *
+ * 2. `NativeModules.PowerAppsDevLauncher` — the dev-player's Expo native module,
+ *    registered in the dev-player APK/IPA regardless of which JS bundle is loaded.
+ *    Fires when a template bundle is loaded via QR-code/URL into the dev-player shell,
+ *    because expo-constants then reflects the template's manifest (no isDevPlayer flag)
+ *    but the native module is still present in the host binary.
+ *
+ * Neither signal fires in a standalone release APK generated from the template, so
+ * `isDevPlayer` is false there and all debug logging is silenced.
+ */
+export declare const isDevPlayer: boolean;
+//# sourceMappingURL=isDevPlayer.d.ts.map

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@microsoft/power-apps-native-host",
+  "version": "0.2.22",
+  "description": "React Native host integration for @microsoft/power-apps",
+  "author": "Microsoft Corporation",
+  "license": "SEE LICENSE IN LICENSE",
+  "bugs": {
+    "email": "pawrap-team@microsoft.com"
+  },
+  "main": "./lib/commonjs/index.js",
+  "module": "./lib/module/index.js",
+  "types": "./lib/typescript/commonjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/typescript/module/index.d.ts",
+        "default": "./lib/module/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/index.d.ts",
+        "default": "./lib/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./app.plugin.js": "./app.plugin.js"
+  },
+  "bin": {
+    "generate-connector-schemas": "scripts/generate-connector-schemas.js",
+    "js-bundle": "scripts/bundle.js",
+    "build-ios-base": "scripts/build-ios-base.js"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map",
+    "app.plugin.js",
+    "scripts/"
+  ],
+  "scripts": {
+    "prepack": "bob build && node ../../scripts/notices.js",
+    "build": "bob build && node ../../scripts/notices.js",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@microsoft/power-apps-native-auth": "^0.3.4",
+    "@microsoft/power-apps-native-common": "^0.1.8",
+    "@tamagui/config": "1.144.4",
+    "@tamagui/core": "1.144.4",
+    "@tamagui/portal": "1.144.4",
+    "@tamagui/toast": "1.144.4",
+    "@tanstack/react-query": "5.62.0"
+  },
+  "peerDependencies": {
+    "@microsoft/power-apps": "*",
+    "@microsoft/power-apps-native-offline": ">=0.1.0",
+    "@react-native-community/netinfo": ">=11.0.0",
+    "burnt": ">=0.12.2",
+    "expo-constants": ">=55.0.0",
+    "expo-linking": ">=55.0.14",
+    "expo-web-browser": ">=55.0.14",
+    "react": ">=19.2.0",
+    "react-native": ">=0.83.4",
+    "react-native-gesture-handler": ">=2.0.0",
+    "react-native-safe-area-context": ">=5.6.2"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-community/netinfo": {
+      "optional": true
+    },
+    "burnt": {
+      "optional": true
+    },
+    "react-native-gesture-handler": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "19.2.14",
+    "cross-env": "7.0.3",
+    "expo-constants": "55.0.16",
+    "expo-web-browser": "55.0.15",
+    "react-native-safe-area-context": "5.6.2",
+    "typescript": "5.9.3"
+  },
+  "keywords": [
+    "power-apps",
+    "react-native",
+    "native-host"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true,
+          "sourceMaps": false
+        }
+      ],
+      [
+        "commonjs",
+        {
+          "esm": true,
+          "sourceMaps": false
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  }
+}

package/scripts/build-ios-base.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * build-ios-base — Build a code-signing-free base IPA for the Power Apps wrap pipeline.
+ *
+ * Equivalent to the one-liner previously in package.json's production:ios script.
+ * Extracts the xcarchive Products into an IPA that the wrap pipeline can re-sign
+ * with the customer's provisioning profile.
+ *
+ * Usage (via npm script in the consuming expo-app):
+ *   build-ios-base
+ *
+ * Output: /tmp/pawrap-base.ipa
+ *
+ * Prerequisites:
+ *   expo prebuild --platform ios --clean   (generates ios/)
+ *   cd ios && pod install
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+const os   = require('os');
+
+if (process.platform !== 'darwin') {
+  console.error('build-ios-base: iOS builds require macOS.');
+  process.exit(1);
+}
+
+// When invoked as an npm binary the cwd is the consuming package.
+const projectRoot = process.cwd();
+const iosDir      = path.join(projectRoot, 'ios');
+
+if (!fs.existsSync(iosDir)) {
+  console.error(
+    'build-ios-base: ios/ directory not found.\n' +
+    'Run: expo prebuild --platform ios --clean && cd ios && pod install'
+  );
+  process.exit(1);
+}
+
+// Locate the generated .xcworkspace — take the first one found.
+const xcworkspace = fs
+  .readdirSync(iosDir)
+  .find((f) => f.endsWith('.xcworkspace'));
+
+if (!xcworkspace) {
+  console.error(
+    'build-ios-base: no .xcworkspace found in ios/.\n' +
+    'Run: expo prebuild --platform ios --clean && cd ios && pod install'
+  );
+  process.exit(1);
+}
+
+// Derive scheme name from workspace name (strip .xcworkspace).
+const scheme = xcworkspace.replace('.xcworkspace', '');
+
+const archivePath = path.join(os.tmpdir(), 'pawrap-base.xcarchive');
+const ipaDir      = path.join(os.tmpdir(), 'pawrap-base-ipa');
+const payloadDir  = path.join(ipaDir, 'Payload');
+const ipaPath     = path.join(os.tmpdir(), 'pawrap-base.ipa');
+
+function run(cmd, args, opts = {}) {
+  console.log(`\n▶ ${cmd} ${args.join(' ')}`);
+  execFileSync(cmd, args, { stdio: 'inherit', ...opts });
+}
+
+// 1. Archive (no code signing — wrap pipeline signs with customer cert).
+run('xcodebuild', [
+  '-workspace', path.join(iosDir, xcworkspace),
+  '-scheme',    scheme,
+  '-configuration', 'Release',
+  'archive',
+  '-archivePath', archivePath,
+  '-destination', 'generic/platform=iOS',
+  'CODE_SIGNING_REQUIRED=NO',
+  'CODE_SIGN_IDENTITY=',
+  'CODE_SIGNING_ALLOWED=NO',
+]);
+
+// 2. Package into an IPA.
+fs.rmSync(ipaDir, { recursive: true, force: true });
+fs.mkdirSync(payloadDir, { recursive: true });
+
+const appsGlob = path.join(archivePath, 'Products', 'Applications');
+for (const app of fs.readdirSync(appsGlob)) {
+  if (app.endsWith('.app')) {
+    fs.cpSync(path.join(appsGlob, app), path.join(payloadDir, app), { recursive: true });
+  }
+}
+
+fs.rmSync(ipaPath, { force: true });
+run('zip', ['-r', ipaPath, '.'], { cwd: ipaDir });
+
+console.log(`\n✓ Base IPA ready: ${ipaPath}`);

package/scripts/bundle.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform Metro → Hermes bundle script.
+ *
+ * Runs two steps:
+ *   1. expo export:embed  — produces a plain Metro JS bundle
+ *   2. hermesc            — compiles it to Hermes bytecode (.hbc)
+ *
+ * Usage (via npm script in the consuming expo-app):
+ *   bundle android   → dist/index.android.bundle.hbc
+ *   bundle ios       → dist/main.jsbundle.hbc
+ *
+ * Works on macOS, Linux, and Windows.
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+
+const platform = process.argv[2];
+if (platform !== 'android' && platform !== 'ios') {
+  console.error('Usage: bundle <android|ios>');
+  process.exit(1);
+}
+
+const isWin   = process.platform === 'win32';
+const isLinux = process.platform === 'linux';
+
+// When invoked as an npm binary the cwd is the consuming package (e.g. templates/expo-app/).
+const projectRoot   = process.cwd();
+const workspaceRoot = path.resolve(projectRoot, '../..');
+
+const distDir = path.join(projectRoot, 'dist');
+fs.mkdirSync(distDir, { recursive: true });
+
+const bundleFile = platform === 'android'
+  ? path.join(distDir, 'index.android.bundle')
+  : path.join(distDir, 'main.jsbundle');
+const assetsDir  = path.join(distDir, platform === 'android' ? 'android-assets' : 'ios-assets');
+const outputFile = bundleFile + '.hbc';
+
+// ── Step 1: Metro bundle ─────────────────────────────────────────────────────
+console.log(`\n[bundle] Step 1: Metro bundle (${platform})`);
+
+// In a standalone project, expo lives in projectRoot/node_modules/.bin/.
+// In an npm workspace (monorepo), binaries are hoisted to workspaceRoot/node_modules/.bin/.
+// Try the project-local bin first so standalone projects work without a monorepo.
+const expoBinName = isWin ? 'expo.cmd' : 'expo';
+const expoBinLocal = path.join(projectRoot, 'node_modules', '.bin', expoBinName);
+const expoBinHoisted = path.join(workspaceRoot, 'node_modules', '.bin', expoBinName);
+const expoBin = fs.existsSync(expoBinLocal) ? expoBinLocal : expoBinHoisted;
+
+// expo export:embed resolveArgs scans argv in reverse; the first non-flag string it encounters
+// (i.e. the LAST positional in the array) is set as projectRoot when i === args.length - 1.
+// So projectRoot must be the final argument.
+//
+// expo-router may be in projectRoot/node_modules (standalone) or workspaceRoot/node_modules (monorepo).
+const entryFileLocal = path.join(projectRoot, 'node_modules', 'expo-router', 'entry.js');
+const entryFileHoisted = path.join(workspaceRoot, 'node_modules', 'expo-router', 'entry.js');
+const entryFile = fs.existsSync(entryFileLocal) ? entryFileLocal : entryFileHoisted;
+
+execFileSync(
+  expoBin,
+  [
+    'export:embed',
+    '--platform', platform,
+    '--entry-file', entryFile,
+    '--bundle-output', bundleFile,
+    '--assets-dest', assetsDir,
+    '--dev', 'false',
+    projectRoot,   // ← must be last: sets expo CLI's projectRoot
+  ],
+  { stdio: 'inherit', cwd: projectRoot },
+);
+
+// ── Step 2: Hermes compile ───────────────────────────────────────────────────
+console.log(`\n[bundle] Step 2: hermesc compile → ${outputFile}`);
+
+const hcPkg = require.resolve('hermes-compiler/package.json', {
+  paths: [projectRoot, workspaceRoot],
+});
+
+const binDir  = isWin ? 'win64-bin' : isLinux ? 'linux64-bin' : 'osx-bin';
+const binName = isWin ? 'hermesc.exe' : 'hermesc';
+// hermes-compiler ships the binary in a subdirectory matching the package name: hermesc/<platform>/hermesc
+const hcDir   = path.dirname(hcPkg);
+const hermesc = fs.existsSync(path.join(hcDir, binDir, binName))
+  ? path.join(hcDir, binDir, binName)
+  : path.join(hcDir, binName, binDir, binName); // fallback: nested hermesc/osx-bin/hermesc
+
+execFileSync(hermesc, ['-emit-binary', '-out', outputFile, bundleFile], { stdio: 'inherit' });
+
+console.log(`\n[bundle] Done. Output: "${outputFile}"`);