@allstak/react-native 0.1.2 → 0.3.0

package/README.md

@@ -1,75 +1,225 @@
-# @allstak-io/react-native
+# @allstak/react-native
 
-AllStak React Native SDK — `ErrorUtils` + Hermes rejection tracking + Platform device tags.  
-Includes native Android (Kotlin) and iOS (Swift) crash capture modules under `./native/`.
+**Native crash + JS error capture for React Native. iOS and Android auto-wired.**
 
-## Install
+[![npm version](https://img.shields.io/npm/v/@allstak/react-native.svg)](https://www.npmjs.com/package/@allstak/react-native)
+[![CI](https://github.com/allstak-io/allstak-react-native/actions/workflows/ci.yml/badge.svg)](https://github.com/allstak-io/allstak-react-native/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> **Auth required:** GitHub Packages requires a token with `read:packages` scope.
+Official AllStak SDK for React Native — hooks `ErrorUtils`, Hermes rejection tracking, and native crash capture on iOS and Android.
 
-### 1. Configure `.npmrc`
+## Dashboard
 
-```ini
-@allstak-io:registry=https://npm.pkg.github.com
-//npm.pkg.github.com/:_authToken=YOUR_GITHUB_PAT
-```
+View captured events live at [app.allstak.sa](https://app.allstak.sa).
+
+![AllStak dashboard](https://app.allstak.sa/images/dashboard-preview.png)
+
+## Features
+
+- `ErrorUtils.setGlobalHandler` integration for JS crash capture
+- Hermes unhandled promise rejection tracking
+- `Platform.OS` / `Platform.Version` auto-tags on every event
+- Native layers (Obj-C/Swift, Java/Kotlin) ship under `native/` for fatal crash capture
+- Breadcrumbs and user/tag context via the shared core API
+- Works with RN 0.70+
+
+## What You Get
+
+Once integrated, every event flows to your AllStak dashboard:
+
+- **JS errors** — stack traces, component names, Hermes rejections
+- **Native crashes** — iOS (Obj-C/Swift) and Android (Java/Kotlin) fatals
+- **Logs** — structured logs with search and filters
+- **HTTP** — outbound request timing, status codes, failed calls
+- **Device tags** — `Platform.OS`, `Platform.Version`, release channel
+- **Alerts** — email and webhook notifications on regressions
 
-### 2. Install
+## Installation
 
 ```bash
-npm install @allstak-io/react-native@0.1.1 @allstak-io/core@0.1.1
-# react-native >=0.70 is an optional peer dep
+npm install @allstak/react-native
 ```
 
-## Usage
+## Quick Start
+
+> Create a project at [app.allstak.sa](https://app.allstak.sa) to get your API key.
 
 ```ts
-import { AllStak } from '@allstak-io/core';
-import { installReactNative } from '@allstak-io/react-native';
+import { Platform } from 'react-native';
+import { AllStak, installReactNative } from '@allstak/react-native';
 
-// Initialize the base SDK
 AllStak.init({
   apiKey: process.env.ALLSTAK_API_KEY!,
   environment: 'production',
-  release: 'v1.0.0',
-  // ingest: 'https://api.allstak.sa'  ← default
+  release: 'com.app@1.0.3+5',
+  dist: Platform.OS,            // 'ios' | 'android' — used as the dashboard filter for binary builds
+  enableHttpTracking: true,     // auto-instrument fetch + XHR + axios — see "HTTP tracking" below
 });
+installReactNative();           // ErrorUtils + Hermes promise rejections + Platform tags
+
+AllStak.captureException(new Error('test: hello from allstak-react-native'));
+```
+
+Run the app — the test error appears in your dashboard within seconds.
+
+## HTTP tracking
+
+Setting `enableHttpTracking: true` (off by default) auto-wraps `fetch`,
+`XMLHttpRequest`, and `axios` (when the latter is installed) so every
+outbound HTTP call is recorded as an `http_request` event.
 
-// Install RN-specific instrumentation
-installReactNative({
-  // Hooks ErrorUtils for uncaught JS errors
-  // Installs Hermes rejection tracking
-  // Tags every event with Platform.OS and Platform.Version
+**Privacy defaults are aggressive — `enableHttpTracking: true` is safe
+to ship to production:**
+
+- request bodies are **not** captured
+- response bodies are **not** captured
+- headers are **not** captured
+- `Authorization`, `Cookie`, `Set-Cookie`, `X-API-Key`, `X-Auth-Token`,
+  `Proxy-Authorization` are **always** redacted
+- query params named `token`, `password`, `api_key`, `apikey`,
+  `authorization`, `auth`, `secret`, `access_token`, `refresh_token`,
+  `session`, `sessionid`, `jwt` are **always** redacted in the URL
+- own-ingest URLs (your AllStak host) are skipped to avoid recursion
+
+Enable richer capture only on routes you control:
+
+```ts
+AllStak.init({
+  apiKey: '...',
+  enableHttpTracking: true,
+  httpTracking: {
+    captureRequestBody: true,           // off by default
+    captureResponseBody: true,          // off by default
+    captureHeaders: true,               // off by default — auth headers still hard-redacted
+    redactHeaders: ['x-tenant'],        // additional names on top of the always-redact list
+    redactQueryParams: ['custom_id'],
+    ignoredUrls: [/health/i, '/metrics'],
+    allowedUrls: [],                    // if non-empty, ONLY these URLs are captured
+    maxBodyBytes: 4096,                 // bodies truncated past this with `…[truncated]`
+  },
 });
 ```
 
-## What's captured automatically after `installReactNative()`
+### axios
+
+If the project uses axios with a non-XHR adapter (rare on RN), explicitly
+instrument the instance — idempotent, so safe to call twice:
+
+```ts
+import axios from 'axios';
+const api = AllStak.instrumentAxios(axios.create({ baseURL: 'https://api.example.com' }));
+```
+
+### Errors auto-link to recent failed requests
+
+When `enableHttpTracking: true` is on, the most recent failed HTTP
+requests (status >= 400 or network error, last 10) are automatically
+attached to the next `captureException` under
+`metadata['http.recentFailed']`. Bodies are NOT included in this
+snapshot unless body capture is enabled — only `method`, `url`,
+`statusCode`, `durationMs`, `error`.
+
+### `dist`
+
+`dist: Platform.OS` is the recommended pattern — it labels every event
+with the binary build (`ios` / `android`) so the dashboard can filter
+to a single platform when triaging.
+
+## Get Your API Key
+
+1. Sign up at [app.allstak.sa](https://app.allstak.sa)
+2. Create a project
+3. Copy your API key from **Project Settings → API Keys**
+4. Export it as `ALLSTAK_API_KEY` or pass it to `installReactNative(...)`
+
+## Configuration
+
+| Option | Type | Required | Default | Description |
+|---|---|---|---|---|
+| `apiKey` | `string` | yes | — | Project API key (`ask_live_…`) |
+| `environment` | `string` | no | — | Deployment env |
+| `release` | `string` | no | — | App version |
+| `host` | `string` | no | `https://api.allstak.sa` | Ingest host override |
+| `user` | `{ id?, email? }` | no | — | Default user context |
+| `tags` | `Record<string,string>` | no | — | Default tags |
+
+## Example Usage
+
+Capture a caught exception:
+
+```ts
+try {
+  await api.fetchFeed();
+} catch (e) {
+  AllStak.captureException(e as Error, { screen: 'Feed' });
+}
+```
+
+Send a log from a screen:
+
+```ts
+AllStak.captureMessage('User opened Settings', 'info');
+```
+
+Tag the current build channel:
+
+```ts
+AllStak.setTag('release-channel', 'beta');
+AllStak.setUser({ id: userId });
+```
 
-| Capability | Notes |
-|-----------|-------|
-| Uncaught JS errors | Via `ErrorUtils.setGlobalHandler` |
-| Unhandled promise rejections | Via Hermes rejection tracking |
-| `Platform.OS` / `Platform.Version` tags | Attached to every event |
+## Production Endpoint
 
-## Native crash capture (Android/iOS)
+Production endpoint: `https://api.allstak.sa`. Override via `host` for self-hosted installs:
+
+```ts
+installReactNative({ apiKey: '...', host: 'https://allstak.mycorp.com' });
+```
 
-Native modules for Java/Kotlin (Android) and Obj-C/Swift (iOS) crash capture are in `./native/`. See [`native/README.md`](./native/README.md) for platform-specific setup.
+## Source maps (Hermes / Metro)
+
+JS bundles produced by Metro (with or without Hermes) are minified in
+release builds — without source-map upload, your dashboard stacks will
+read like `at e (index.bundle:1:42031)`. Wire it up once during release
+build via `@allstak/js/sourcemaps` (devDependency only):
+
+```bash
+npm install -D @allstak/js
+```
+
+```sh
+# Build the release bundle as you normally would
+npx react-native bundle \
+  --platform android --dev false --entry-file index.js \
+  --bundle-output android-release.bundle \
+  --sourcemap-output android-release.bundle.map
+
+# Hermes-compile (if Hermes is enabled — the default on RN 0.70+)
+hermes-compiler --emit-binary --output-source-map \
+  -out android-release.hbc android-release.bundle
+
+# Upload to AllStak — debugId injection + map upload
+node -e "import('@allstak/js/sourcemaps').then(({ processBuildOutput }) => \
+  processBuildOutput({ dir: '.', release: process.env.RELEASE, \
+    token: process.env.ALLSTAK_UPLOAD_TOKEN }))"
+```
 
-## API
+For iOS (`react-native bundle --platform ios`) the same flow applies.
+Add this as a release-only step in your CI; the runtime SDK reads the
+`debugId` from each frame and resolves the matching map server-side.
 
-| Export | Description |
-|--------|-------------|
-| `AllStak` | Re-exported from `@allstak-io/core` |
-| `installReactNative(opts?)` | Hooks ErrorUtils + Hermes + device tags |
-| `ReactNativeInstallOptions` | Options type for `installReactNative` |
+> **Status:** the upload pipeline is the same one used by the web SDK
+> and is unit-tested in `@allstak/js/tests/sourcemaps-*.test.ts`. Native
+> Hermes-bytecode mapping has not yet been integration-tested end-to-end
+> against the AllStak symbolicator on a real device build — flag any
+> off-by-one source maps in [issues](https://github.com/AllStak/allstak-react-native/issues).
 
-## GitHub Packages
+## Links
 
-- **Package:** `@allstak-io/react-native`
-- **Registry:** `https://npm.pkg.github.com`
-- **Repo:** [github.com/allstak-io/allstak-react-native](https://github.com/allstak-io/allstak-react-native)
-- **Releases:** [github.com/allstak-io/allstak-react-native/releases](https://github.com/allstak-io/allstak-react-native/releases)
+- Documentation: https://docs.allstak.sa
+- Dashboard: https://app.allstak.sa
+- Source: https://github.com/allstak-io/allstak-react-native
 
-## Versioning
+## License
 
-Tags must match `package.json` version exactly (e.g. `v0.1.1`). The release workflow fails if there's a mismatch.
+MIT © AllStak

package/app.plugin.js

@@ -0,0 +1,6 @@
+// Expo entrypoint — re-exports the actual plugin from `dist/expo-plugin.js`
+// so consumers can write `"plugins": ["@allstak/react-native"]` in their
+// app.json and Expo's `withPlugins` resolver finds it without an extra
+// import path. Expo looks for `app.plugin.js` at the package root by
+// convention.
+module.exports = require('./dist/expo-plugin.js');

package/dist/chunk-BJTO5JO5.mjs

@@ -0,0 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};
+//# sourceMappingURL=chunk-BJTO5JO5.mjs.map

package/dist/chunk-BJTO5JO5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/expo-plugin.d.mts

@@ -0,0 +1,56 @@
+/**
+ * Expo config plugin.
+ *
+ * Apply via `app.json`:
+ *
+ *   {
+ *     "expo": {
+ *       "plugins": [
+ *         ["@allstak/react-native", { "release": "mobile@1.2.3", "environment": "production" }]
+ *       ]
+ *     }
+ *   }
+ *
+ * The plugin runs at `expo prebuild` / EAS build time and:
+ *
+ *   1. Adds the AllStak iOS pod (declared in `react-native.config.js`).
+ *      Expo's autolinking already picks this up — we just record metadata
+ *      so `expo doctor` can verify the install is wired.
+ *   2. Stamps the chosen `release` into `expo-constants` extras so the JS
+ *      layer can read it at runtime via `Constants.expoConfig.extra._allstak`
+ *      without the host app needing to plumb it through env vars.
+ *   3. Records that `@allstak/react-native` was loaded as an Expo plugin
+ *      for diagnostics.
+ *
+ * Pure config mutation — no native code is patched here. The native iOS
+ * + Android modules under ./native are linked by Expo's existing
+ * autolinking flow (which honors the `react-native.config.js` manifest).
+ */
+interface AllStakExpoOptions {
+    /** Release identifier (e.g. `mobile@1.2.3`). Stamped into `Constants.expoConfig.extra._allstak.release`. */
+    release?: string;
+    /** Environment label — `production`, `staging`, etc. */
+    environment?: string;
+    /** Optional dist tag (e.g. `ios-hermes`). Auto-detected at runtime if unset. */
+    dist?: string;
+}
+interface ExpoConfig {
+    name?: string;
+    extra?: Record<string, unknown>;
+    plugins?: any[];
+    [key: string]: any;
+}
+interface ExpoConfigContext {
+    modResults?: any;
+    modRawConfig?: ExpoConfig;
+    [key: string]: any;
+}
+/**
+ * The plugin function itself. Expo's plugin runner calls it as
+ * `(config, options) => modifiedConfig`. We avoid importing
+ * `@expo/config-plugins` so the package has zero hard dependencies on the
+ * Expo toolchain — the type checking happens at usage site instead.
+ */
+declare function withAllStak(config: ExpoConfig & ExpoConfigContext, options?: AllStakExpoOptions): ExpoConfig;
+
+export { type AllStakExpoOptions, withAllStak as default };

package/dist/expo-plugin.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Expo config plugin.
+ *
+ * Apply via `app.json`:
+ *
+ *   {
+ *     "expo": {
+ *       "plugins": [
+ *         ["@allstak/react-native", { "release": "mobile@1.2.3", "environment": "production" }]
+ *       ]
+ *     }
+ *   }
+ *
+ * The plugin runs at `expo prebuild` / EAS build time and:
+ *
+ *   1. Adds the AllStak iOS pod (declared in `react-native.config.js`).
+ *      Expo's autolinking already picks this up — we just record metadata
+ *      so `expo doctor` can verify the install is wired.
+ *   2. Stamps the chosen `release` into `expo-constants` extras so the JS
+ *      layer can read it at runtime via `Constants.expoConfig.extra._allstak`
+ *      without the host app needing to plumb it through env vars.
+ *   3. Records that `@allstak/react-native` was loaded as an Expo plugin
+ *      for diagnostics.
+ *
+ * Pure config mutation — no native code is patched here. The native iOS
+ * + Android modules under ./native are linked by Expo's existing
+ * autolinking flow (which honors the `react-native.config.js` manifest).
+ */
+interface AllStakExpoOptions {
+    /** Release identifier (e.g. `mobile@1.2.3`). Stamped into `Constants.expoConfig.extra._allstak.release`. */
+    release?: string;
+    /** Environment label — `production`, `staging`, etc. */
+    environment?: string;
+    /** Optional dist tag (e.g. `ios-hermes`). Auto-detected at runtime if unset. */
+    dist?: string;
+}
+interface ExpoConfig {
+    name?: string;
+    extra?: Record<string, unknown>;
+    plugins?: any[];
+    [key: string]: any;
+}
+interface ExpoConfigContext {
+    modResults?: any;
+    modRawConfig?: ExpoConfig;
+    [key: string]: any;
+}
+/**
+ * The plugin function itself. Expo's plugin runner calls it as
+ * `(config, options) => modifiedConfig`. We avoid importing
+ * `@expo/config-plugins` so the package has zero hard dependencies on the
+ * Expo toolchain — the type checking happens at usage site instead.
+ */
+declare function withAllStak(config: ExpoConfig & ExpoConfigContext, options?: AllStakExpoOptions): ExpoConfig;
+
+export { type AllStakExpoOptions, withAllStak as default };

package/dist/expo-plugin.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/expo-plugin.ts
+var expo_plugin_exports = {};
+__export(expo_plugin_exports, {
+  default: () => expo_plugin_default
+});
+module.exports = __toCommonJS(expo_plugin_exports);
+function withAllStak(config, options = {}) {
+  const next = { ...config };
+  next.extra = { ...config.extra ?? {} };
+  const existing = next.extra._allstak ?? {};
+  next.extra._allstak = {
+    ...existing,
+    release: options.release ?? existing.release,
+    environment: options.environment ?? existing.environment,
+    dist: options.dist ?? existing.dist,
+    pluginVersion: "0.3.0"
+  };
+  return next;
+}
+var expo_plugin_default = withAllStak;
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = withAllStak;
+  module.exports.default = withAllStak;
+}
+//# sourceMappingURL=expo-plugin.js.map

package/dist/expo-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/expo-plugin.ts"],"sourcesContent":["/**\n * Expo config plugin.\n *\n * Apply via `app.json`:\n *\n *   {\n *     \"expo\": {\n *       \"plugins\": [\n *         [\"@allstak/react-native\", { \"release\": \"mobile@1.2.3\", \"environment\": \"production\" }]\n *       ]\n *     }\n *   }\n *\n * The plugin runs at `expo prebuild` / EAS build time and:\n *\n *   1. Adds the AllStak iOS pod (declared in `react-native.config.js`).\n *      Expo's autolinking already picks this up — we just record metadata\n *      so `expo doctor` can verify the install is wired.\n *   2. Stamps the chosen `release` into `expo-constants` extras so the JS\n *      layer can read it at runtime via `Constants.expoConfig.extra._allstak`\n *      without the host app needing to plumb it through env vars.\n *   3. Records that `@allstak/react-native` was loaded as an Expo plugin\n *      for diagnostics.\n *\n * Pure config mutation — no native code is patched here. The native iOS\n * + Android modules under ./native are linked by Expo's existing\n * autolinking flow (which honors the `react-native.config.js` manifest).\n */\n\nexport interface AllStakExpoOptions {\n  /** Release identifier (e.g. `mobile@1.2.3`). Stamped into `Constants.expoConfig.extra._allstak.release`. */\n  release?: string;\n  /** Environment label — `production`, `staging`, etc. */\n  environment?: string;\n  /** Optional dist tag (e.g. `ios-hermes`). Auto-detected at runtime if unset. */\n  dist?: string;\n}\n\ninterface ExpoConfig {\n  name?: string;\n  extra?: Record<string, unknown>;\n  plugins?: any[];\n  [key: string]: any;\n}\n\ninterface ExpoConfigContext {\n  modResults?: any;\n  modRawConfig?: ExpoConfig;\n  [key: string]: any;\n}\n\n/**\n * The plugin function itself. Expo's plugin runner calls it as\n * `(config, options) => modifiedConfig`. We avoid importing\n * `@expo/config-plugins` so the package has zero hard dependencies on the\n * Expo toolchain — the type checking happens at usage site instead.\n */\nfunction withAllStak(config: ExpoConfig & ExpoConfigContext, options: AllStakExpoOptions = {}): ExpoConfig {\n  const next: ExpoConfig = { ...config };\n  next.extra = { ...(config.extra ?? {}) };\n\n  // Embed runtime-readable metadata under a namespaced key so we never\n  // collide with the host app's other extras.\n  const existing = (next.extra as any)._allstak ?? {};\n  (next.extra as any)._allstak = {\n    ...existing,\n    release: options.release ?? existing.release,\n    environment: options.environment ?? existing.environment,\n    dist: options.dist ?? existing.dist,\n    pluginVersion: '0.3.0',\n  };\n\n  return next;\n}\n\nexport default withAllStak;\n\n// Expose as a CommonJS function so `app.plugin.js`'s `require('./dist/expo-plugin.js')`\n// returns the plugin directly. The `declare const module` keeps the TS\n// type-checker happy without dragging in @types/node.\ndeclare const module: { exports: any };\nif (typeof module !== 'undefined' && module.exports) {\n  module.exports = withAllStak;\n  module.exports.default = withAllStak;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyDA,SAAS,YAAY,QAAwC,UAA8B,CAAC,GAAe;AACzG,QAAM,OAAmB,EAAE,GAAG,OAAO;AACrC,OAAK,QAAQ,EAAE,GAAI,OAAO,SAAS,CAAC,EAAG;AAIvC,QAAM,WAAY,KAAK,MAAc,YAAY,CAAC;AAClD,EAAC,KAAK,MAAc,WAAW;AAAA,IAC7B,GAAG;AAAA,IACH,SAAS,QAAQ,WAAW,SAAS;AAAA,IACrC,aAAa,QAAQ,eAAe,SAAS;AAAA,IAC7C,MAAM,QAAQ,QAAQ,SAAS;AAAA,IAC/B,eAAe;AAAA,EACjB;AAEA,SAAO;AACT;AAEA,IAAO,sBAAQ;AAMf,IAAI,OAAO,WAAW,eAAe,OAAO,SAAS;AACnD,SAAO,UAAU;AACjB,SAAO,QAAQ,UAAU;AAC3B;","names":[]}

package/dist/expo-plugin.mjs

@@ -0,0 +1,25 @@
+import "./chunk-BJTO5JO5.mjs";
+
+// src/expo-plugin.ts
+function withAllStak(config, options = {}) {
+  const next = { ...config };
+  next.extra = { ...config.extra ?? {} };
+  const existing = next.extra._allstak ?? {};
+  next.extra._allstak = {
+    ...existing,
+    release: options.release ?? existing.release,
+    environment: options.environment ?? existing.environment,
+    dist: options.dist ?? existing.dist,
+    pluginVersion: "0.3.0"
+  };
+  return next;
+}
+var expo_plugin_default = withAllStak;
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = withAllStak;
+  module.exports.default = withAllStak;
+}
+export {
+  expo_plugin_default as default
+};
+//# sourceMappingURL=expo-plugin.mjs.map

package/dist/expo-plugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/expo-plugin.ts"],"sourcesContent":["/**\n * Expo config plugin.\n *\n * Apply via `app.json`:\n *\n *   {\n *     \"expo\": {\n *       \"plugins\": [\n *         [\"@allstak/react-native\", { \"release\": \"mobile@1.2.3\", \"environment\": \"production\" }]\n *       ]\n *     }\n *   }\n *\n * The plugin runs at `expo prebuild` / EAS build time and:\n *\n *   1. Adds the AllStak iOS pod (declared in `react-native.config.js`).\n *      Expo's autolinking already picks this up — we just record metadata\n *      so `expo doctor` can verify the install is wired.\n *   2. Stamps the chosen `release` into `expo-constants` extras so the JS\n *      layer can read it at runtime via `Constants.expoConfig.extra._allstak`\n *      without the host app needing to plumb it through env vars.\n *   3. Records that `@allstak/react-native` was loaded as an Expo plugin\n *      for diagnostics.\n *\n * Pure config mutation — no native code is patched here. The native iOS\n * + Android modules under ./native are linked by Expo's existing\n * autolinking flow (which honors the `react-native.config.js` manifest).\n */\n\nexport interface AllStakExpoOptions {\n  /** Release identifier (e.g. `mobile@1.2.3`). Stamped into `Constants.expoConfig.extra._allstak.release`. */\n  release?: string;\n  /** Environment label — `production`, `staging`, etc. */\n  environment?: string;\n  /** Optional dist tag (e.g. `ios-hermes`). Auto-detected at runtime if unset. */\n  dist?: string;\n}\n\ninterface ExpoConfig {\n  name?: string;\n  extra?: Record<string, unknown>;\n  plugins?: any[];\n  [key: string]: any;\n}\n\ninterface ExpoConfigContext {\n  modResults?: any;\n  modRawConfig?: ExpoConfig;\n  [key: string]: any;\n}\n\n/**\n * The plugin function itself. Expo's plugin runner calls it as\n * `(config, options) => modifiedConfig`. We avoid importing\n * `@expo/config-plugins` so the package has zero hard dependencies on the\n * Expo toolchain — the type checking happens at usage site instead.\n */\nfunction withAllStak(config: ExpoConfig & ExpoConfigContext, options: AllStakExpoOptions = {}): ExpoConfig {\n  const next: ExpoConfig = { ...config };\n  next.extra = { ...(config.extra ?? {}) };\n\n  // Embed runtime-readable metadata under a namespaced key so we never\n  // collide with the host app's other extras.\n  const existing = (next.extra as any)._allstak ?? {};\n  (next.extra as any)._allstak = {\n    ...existing,\n    release: options.release ?? existing.release,\n    environment: options.environment ?? existing.environment,\n    dist: options.dist ?? existing.dist,\n    pluginVersion: '0.3.0',\n  };\n\n  return next;\n}\n\nexport default withAllStak;\n\n// Expose as a CommonJS function so `app.plugin.js`'s `require('./dist/expo-plugin.js')`\n// returns the plugin directly. The `declare const module` keeps the TS\n// type-checker happy without dragging in @types/node.\ndeclare const module: { exports: any };\nif (typeof module !== 'undefined' && module.exports) {\n  module.exports = withAllStak;\n  module.exports.default = withAllStak;\n}\n"],"mappings":";;;AAyDA,SAAS,YAAY,QAAwC,UAA8B,CAAC,GAAe;AACzG,QAAM,OAAmB,EAAE,GAAG,OAAO;AACrC,OAAK,QAAQ,EAAE,GAAI,OAAO,SAAS,CAAC,EAAG;AAIvC,QAAM,WAAY,KAAK,MAAc,YAAY,CAAC;AAClD,EAAC,KAAK,MAAc,WAAW;AAAA,IAC7B,GAAG;AAAA,IACH,SAAS,QAAQ,WAAW,SAAS;AAAA,IACrC,aAAa,QAAQ,eAAe,SAAS;AAAA,IAC7C,MAAM,QAAQ,QAAQ,SAAS;AAAA,IAC/B,eAAe;AAAA,EACjB;AAEA,SAAO;AACT;AAEA,IAAO,sBAAQ;AAMf,IAAI,OAAO,WAAW,eAAe,OAAO,SAAS;AACnD,SAAO,UAAU;AACjB,SAAO,QAAQ,UAAU;AAC3B;","names":[]}