@scalebun-release/react-native 2.5.0

package/lib/commonjs/metro/index.js

@@ -0,0 +1,230 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SCALEBUN_OPTIONAL_MODULES", {
+  enumerable: true,
+  get: function () {
+    return _optionalModules.SCALEBUN_OPTIONAL_MODULES;
+  }
+});
+exports.default = void 0;
+exports.withScaleBun = withScaleBun;
+var nodePath = _interopRequireWildcard(require("path"));
+var nodeFs = _interopRequireWildcard(require("fs"));
+var _optionalModules = require("./optionalModules");
+var _featureModules = require("./featureModules");
+var _serializerCompose = require("./serializerCompose");
+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); }
+/**
+ * ScaleBun SDK — Metro configuration helper.
+ *
+ * PURPOSE
+ * The SDK integrates OPTIONALLY with a few third-party packages (screenshots,
+ * Notifee, Expo Router). Each is loaded through a guarded lazy `require()` at
+ * runtime, but Metro statically resolves every literal `require('<name>')` at
+ * BUNDLE time — before the runtime `try/catch` runs — so a host that does not
+ * install one of these packages fails to bundle with:
+ *
+ *     Unable to resolve module <name>
+ *
+ * `withScaleBun` wraps a host's Metro config so that, ONLY for ScaleBun's own
+ * optional integration packages, a failed resolution falls back to an empty
+ * stub module shipped inside the SDK. Everything else resolves exactly as before
+ * and unrelated missing modules still fail normally.
+ *
+ * This entry point is deliberately Node-only: it imports no React Native, no
+ * native modules, and no SDK runtime code, so it is safe to `require()` from a
+ * CommonJS `metro.config.js`.
+ *
+ * Resolution order for every request:
+ *   host's custom resolveRequest (if any) → Metro's default resolver →
+ *   on failure, if the name is a known ScaleBun optional module → empty stub;
+ *   otherwise the original resolution error is rethrown.
+ */
+
+// Minimal structural types for the slice of Metro's resolver API we touch. We
+// avoid a hard dependency on `metro`/`metro-resolver` types so the helper builds
+// even in hosts that don't expose them, while staying accurate for Metro >=0.64.
+
+/**
+ * Absolute path to the shipped empty stub. Resolved once at load. `require.resolve`
+ * is portable across the compiled package (`optionalDependencyStub.js` sibling)
+ * and the ts-jest test runtime (`.ts` sibling). If it throws, the package is
+ * packed incorrectly and we surface a clear, actionable error immediately.
+ */
+function resolveStubPath() {
+  try {
+    return require.resolve('./optionalDependencyStub');
+  } catch (cause) {
+    throw new Error('[scalebun/metro] Could not locate the optional-dependency stub ' + '(optionalDependencyStub). The @scalebun/react-native package may be ' + 'installed incorrectly or incomplete — try reinstalling it.', {
+      cause
+    });
+  }
+}
+
+/**
+ * Absolute path to this package's root, found by walking up from this file until a package.json
+ * naming this package appears.
+ *
+ * Computed by search rather than a fixed number of `..` segments because this module is emitted to
+ * different depths (`lib/commonjs/metro/` when published, `src/metro/` under ts-jest), and a
+ * hard-coded depth would silently resolve to the wrong directory in one of them.
+ *
+ * Returns null if the root cannot be identified, in which case feature exclusion is skipped
+ * entirely — stubbing on a tail match alone could hit a host application's own files.
+ */
+function findPackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const manifest = nodePath.join(dir, 'package.json');
+      if (nodeFs.existsSync(manifest)) {
+        const name = JSON.parse(nodeFs.readFileSync(manifest, 'utf8'))?.name;
+        if (name === '@scalebun/react-native') return nodeFs.realpathSync(dir);
+      }
+    } catch {
+      // Unreadable/malformed manifest — keep walking rather than failing the whole build.
+    }
+    const parent = nodePath.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Is `filePath` inside this package?
+ *
+ * Both sides are realpath'd because pnpm and npm workspaces symlink the package into
+ * `node_modules`, so Metro can hand back a path through the symlink while the package root was
+ * discovered through the store — a plain prefix comparison would then miss and quietly disable
+ * exclusion. Falls back to the raw path when realpath fails (file may not exist yet).
+ */
+function isInsidePackage(filePath, packageRoot) {
+  let real = filePath;
+  try {
+    real = nodeFs.realpathSync(filePath);
+  } catch {
+    // Keep the original path; the relative check below still gives a correct answer for
+    // anything that genuinely lives under the package root.
+  }
+  const rel = nodePath.relative(packageRoot, real);
+  return rel !== '' && !rel.startsWith('..') && !nodePath.isAbsolute(rel);
+}
+
+/**
+ * Wrap a Metro configuration so the SDK's optional integration packages resolve
+ * to an empty stub when they are not installed.
+ *
+ * @param config  A Metro config (typically the result of `mergeConfig(...)`).
+ * @param options Optional extra module names to treat as ScaleBun-optional.
+ * @returns A NEW config object; the input and its `resolver` are not mutated.
+ */
+function withScaleBun(config, options = {}) {
+  if (config == null || typeof config !== 'object') {
+    throw new Error('[scalebun/metro] withScaleBun(config) expects a Metro config object. ' + 'Pass it the result of mergeConfig(getDefaultConfig(__dirname), {}).');
+  }
+  const stubPath = resolveStubPath();
+  const optionalModules = new Set([..._optionalModules.SCALEBUN_OPTIONAL_MODULES, ...(options.optionalModules ?? [])]);
+
+  // Throws on an unknown feature name, at config load, rather than silently shipping code the
+  // caller believed they had excluded.
+  const excludedModules = (0, _featureModules.resolveExcludedModules)(options.features);
+  const packageRoot = findPackageRoot();
+  if (excludedModules.size > 0 && packageRoot == null) {
+    throw new Error('[scalebun/metro] features were requested but the @scalebun/react-native package root ' + 'could not be located from ' + __dirname + '. Refusing to exclude modules by path suffix alone, because that could stub files ' + "belonging to your own app. Reinstall the package, or drop the `features` option.");
+  }
+
+  // The pre-bundled artifacts. Package exports resolve "@scalebun/react-native" to the slim one;
+  // `features: { devTools: true }` redirects to the full one below. When the package was built
+  // without dist/ (working from raw source), both lists are empty and every dist-dependent
+  // behaviour degrades to the per-file lib/ path.
+  const artifacts = packageRoot ? (0, _serializerCompose.discoverArtifacts)(packageRoot) : [];
+  const fullArtifact = artifacts.find(a => a.artifactPath.endsWith('scalebun.full.js'));
+  const wantsDevTools = options.features?.devTools === true;
+  if (wantsDevTools && artifacts.length > 0 && !fullArtifact) {
+    throw new Error('[scalebun/metro] features.devTools is true but dist/scalebun.full.js is missing from ' + 'the installed package. Reinstall @scalebun/react-native.');
+  }
+
+  // Preserve a host-provided resolver so aliases, monorepo/PnP, SVG, NativeWind,
+  // Storybook, Expo, etc. keep working. We call it first and only add a fallback.
+  const hostResolveRequest = config.resolver?.resolveRequest;
+  const resolveRequest = (context, moduleName, platform) => {
+    // Prefer the host resolver; otherwise Metro's default (always on context).
+    const baseResolve = hostResolveRequest ?? context.resolveRequest;
+    if (typeof baseResolve !== 'function') {
+      throw new Error('[scalebun/metro] This Metro version does not expose a resolver ' + "callback on the resolution context. withScaleBun requires Metro's " + 'custom `resolver.resolveRequest` API (Metro >= 0.64, React Native ' + '>= 0.64). Upgrade Metro/React Native or remove withScaleBun.');
+    }
+
+    // devTools opt-in: the package's exports point at the slim artifact, so the full one is
+    // reachable only through this redirect. Matching the bare specifier is safe here — it is
+    // the package's own name, which nothing else can legitimately claim.
+    if (wantsDevTools && fullArtifact && moduleName === '@scalebun/react-native') {
+      return {
+        type: 'sourceFile',
+        filePath: fullArtifact.artifactPath
+      };
+    }
+    let resolution;
+    try {
+      resolution = baseResolve(context, moduleName, platform);
+    } catch (error) {
+      if (optionalModules.has(moduleName)) {
+        // Known ScaleBun optional integration, not installed → empty stub.
+        return {
+          type: 'sourceFile',
+          filePath: stubPath
+        };
+      }
+      // Unrelated module: preserve Metro's original failure exactly.
+      throw error;
+    }
+
+    // Feature exclusion is decided on the RESOLVED path, never on the request string: one
+    // module is reached through many different relative specifiers, and only a resolved path
+    // can be confirmed to live inside this package. That containment check is the safety
+    // property — a tail match alone would also stub a host app's own `debug/commands.js`.
+    if (packageRoot != null && resolution != null && resolution.type === 'sourceFile' && typeof resolution.filePath === 'string' && isInsidePackage(resolution.filePath, packageRoot) && (0, _featureModules.isExcludedModule)(resolution.filePath, excludedModules)) {
+      return {
+        type: 'sourceFile',
+        filePath: stubPath
+      };
+    }
+    return resolution;
+  };
+
+  // ── Source-map composition (symbolication correct by default) ───────────────────────────
+  // The pre-bundled artifact collapses SDK frames to one generated file in Metro's map, and
+  // Metro cannot chain input maps. Wrapping the serializer here means the .map every consumer
+  // build writes already resolves SDK frames to original TypeScript — wherever it is uploaded.
+  let serializerConfig = config.serializer;
+  if (artifacts.length > 0) {
+    // Anchor metro resolution at the app: its projectRoot when the config carries one, else
+    // the bundling process's cwd (react-native CLI runs from the app root).
+    const projectRoot = config.projectRoot;
+    const internals = (0, _serializerCompose.resolveMetroInternals)([...(typeof projectRoot === 'string' ? [projectRoot] : []), process.cwd()]);
+    if (internals == null) {
+      // eslint-disable-next-line no-console
+      console.warn('[scalebun/metro] Could not load Metro serialization internals from this Metro ' + "version, so ScaleBun's source-map composition is disabled. Builds work, but " + 'SDK stack frames will symbolicate to the bundled artifact instead of original ' + 'sources. Please report your Metro version to ScaleBun.');
+    } else {
+      serializerConfig = {
+        ...serializerConfig,
+        customSerializer: (0, _serializerCompose.createComposingSerializer)(artifacts, internals, serializerConfig?.customSerializer)
+      };
+    }
+  }
+  return {
+    ...config,
+    resolver: {
+      ...config.resolver,
+      resolveRequest
+    },
+    ...(serializerConfig !== undefined ? {
+      serializer: serializerConfig
+    } : {})
+  };
+}
+var _default = exports.default = withScaleBun;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/metro/optionalDependencyStub.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=optionalDependencyStub.js.map

package/lib/commonjs/metro/optionalModules.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SCALEBUN_OPTIONAL_MODULES = void 0;
+/**
+ * ScaleBun SDK — Optional integration module registry.
+ *
+ * Single source of truth for the third-party packages the SDK integrates with
+ * OPTIONALLY. Each is loaded through a guarded, lazy `require()` at runtime, so a
+ * host that does not use the integration never needs the package at runtime.
+ *
+ * Metro, however, statically resolves every literal `require('<name>')` string at
+ * bundle time — BEFORE the runtime `try/catch` can execute — so an uninstalled
+ * package fails the bundle with "Unable to resolve module <name>". `withScaleBun`
+ * (see ./index) stubs exactly these names when they are absent so bundling
+ * succeeds while the integration stays disabled. See FIX_PUSH_UNKNOWN_MODULE.md.
+ *
+ * IMPORTANT: keep this list narrow. Only ScaleBun's own optional integrations
+ * belong here. Never add a package the SDK does not knowingly `require()`, so an
+ * unrelated missing module still fails resolution normally.
+ */
+const SCALEBUN_OPTIONAL_MODULES = exports.SCALEBUN_OPTIONAL_MODULES = [
+// Screenshot capture for the journey/replay screenshot helper.
+'react-native-view-shot',
+// Notifee notification-channel integration in the FCM push adapter.
+'@notifee/react-native',
+// Expo Router navigation-mode detection.
+'expo-router'];
+//# sourceMappingURL=optionalModules.js.map

package/lib/commonjs/metro/serializerCompose.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createComposingSerializer = createComposingSerializer;
+exports.discoverArtifacts = discoverArtifacts;
+exports.resolveMetroInternals = resolveMetroInternals;
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+var _composeSourceMap = require("./composeSourceMap");
+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); }
+/**
+ * ScaleBun SDK — Metro serializer wrapper that emits a COMPOSED source map.
+ *
+ * Attached by `withScaleBun`. Reproduces Metro's default serialization (the exact calls
+ * Server.js makes when no custom serializer is configured), then rewrites every mapping that
+ * lands in a ScaleBun pre-bundled artifact through that artifact's stage-2 map, so the .map the
+ * build writes resolves SDK frames to original TypeScript — by default, for every consumer.
+ *
+ * Cooperation with a host-configured serializer: the host runs first and its code output is
+ * respected verbatim. If it returned its own map, that map is composed; if it returned only a
+ * string, the map is built from the graph exactly as Metro itself would have, then composed —
+ * either way the host loses nothing and gains correct SDK frames.
+ *
+ * Metro's serialization internals are reached through the "./private/*" exports alias
+ * (Metro >= 0.80.6) with a fallback to the bare "./src/*" paths older versions expose. If
+ * neither resolves, the wrapper is NOT attached and one warning explains what degrades —
+ * bundling must never fail because symbolication couldn't be improved.
+ */
+
+// ─── Minimal structural types for the slice of Metro's serializer API we touch ─────────────────
+
+/**
+ * Resolve Metro's serialization helpers from the HOST's Metro install. Returns null when they
+ * cannot be found (exotic Metro version/layout) — callers must degrade gracefully.
+ *
+ * Resolution is anchored at the APP (project root / cwd), never at this package's own location:
+ * `metro` is not a dependency of the SDK, so under pnpm's strict layout a bare require from here
+ * finds nothing — and even where it would resolve, the app's Metro is the one whose serializer
+ * contract must be matched, not whichever copy happens to sit near the SDK.
+ */
+function resolveMetroInternals(searchPaths) {
+  const paths = [...searchPaths.filter(Boolean)];
+  const req = spec => require(require.resolve(spec, {
+    paths
+  }));
+  for (const prefix of ['metro/private', 'metro/src']) {
+    try {
+      const base = req(`${prefix}/DeltaBundler/Serializers/baseJSBundle`);
+      const bts = req(`${prefix}/lib/bundleToString`);
+      const smo = req(`${prefix}/DeltaBundler/Serializers/sourceMapObject`);
+      const baseJSBundle = base.default ?? base;
+      const bundleToString = bts.default ?? bts;
+      const sourceMapObject = smo.sourceMapObject ?? smo.default ?? smo;
+      if (typeof baseJSBundle === 'function' && typeof bundleToString === 'function' && typeof sourceMapObject === 'function') {
+        return {
+          baseJSBundle,
+          bundleToString,
+          sourceMapObject
+        };
+      }
+    } catch {
+      // try the next prefix
+    }
+  }
+  return null;
+}
+
+/** The artifacts a package root can contain, with existence checked once at config time. */
+function discoverArtifacts(packageRoot) {
+  const out = [];
+  for (const name of ['scalebun.slim.js', 'scalebun.full.js']) {
+    const artifactPath = path.join(packageRoot, 'dist', name);
+    const mapPath = artifactPath + '.map';
+    if (fs.existsSync(artifactPath) && fs.existsSync(mapPath)) {
+      out.push({
+        artifactPath,
+        mapPath
+      });
+    }
+  }
+  return out;
+}
+
+/** One-shot guard so an Expo build does not print the pass-through notice per bundle. */
+let warnedUnknownShape = false;
+
+/**
+ * Build the composing serializer. `hostSerializer` is the app's own customSerializer, if any.
+ */
+function createComposingSerializer(artifacts, internals, hostSerializer) {
+  return async (entryPoint, preModules, graph, options) => {
+    let code;
+    let mapObj = null;
+    if (hostSerializer) {
+      const hostResult = await hostSerializer(entryPoint, preModules, graph, options);
+      if (typeof hostResult === 'string') {
+        code = hostResult;
+      } else if (hostResult && typeof hostResult.code !== 'string') {
+        /**
+         * A shape this wrapper does not understand — pass it back UNTOUCHED.
+         *
+         * Expo is the case that matters. `expo/metro-config` installs a
+         * serializer returning `{ artifacts: [...] }`, a multi-artifact
+         * shape with no top-level `code`. Reading `.code` off it yielded
+         * undefined, and returning `{ code: undefined, map }` made every
+         * `expo export:embed` die with:
+         *
+         *   Serializer did not return expected format. The project copy
+         *   of `expo/metro-config` may be out of date.
+         *
+         * — a message that sends you to upgrade Expo, which is not the
+         * problem. The result: `withScaleBun` broke PRODUCTION BUNDLING
+         * FOR EVERY EXPO APP, and the SDK's own marketing test app could
+         * not build. Found by bundling it.
+         *
+         * Passing it through costs ScaleBun's source-map composition on
+         * Expo (OTA stack traces stay mapped to the bundle rather than to
+         * original sources). That is a real loss and strictly better than
+         * a build that cannot run at all. Composing INTO an artifact
+         * array is the follow-up; it must not be guessed at here.
+         */
+        if (!warnedUnknownShape) {
+          warnedUnknownShape = true;
+          console.warn('[ScaleBun/metro] The host serializer returned a shape this SDK does not ' + 'compose (Expo returns { artifacts }). Passing it through unchanged — ' + 'the build is correct, but ScaleBun source-map composition is skipped.');
+        }
+        return hostResult;
+      } else {
+        code = hostResult.code;
+        try {
+          mapObj = JSON.parse(hostResult.map);
+        } catch {
+          // Host emitted an unparsable map; fall through and rebuild from the graph so
+          // the build still succeeds with a correct map rather than failing here.
+          mapObj = null;
+        }
+      }
+    } else {
+      code = internals.bundleToString(internals.baseJSBundle(entryPoint, preModules, graph, options)).code;
+    }
+    if (mapObj == null) {
+      // Metro's own fallback, replicated: modules sorted by module id, same options.
+      const modules = [...graph.dependencies.values()].sort((a, b) => options.createModuleId(a.path) - options.createModuleId(b.path));
+      mapObj = internals.sourceMapObject([...preModules, ...modules], {
+        excludeSource: options.excludeSource,
+        processModuleFilter: options.processModuleFilter,
+        shouldAddToIgnoreList: options.shouldAddToIgnoreList,
+        getSourceUrl: options.getSourceUrl
+      });
+    }
+    const {
+      map
+    } = (0, _composeSourceMap.composeSourceMap)(mapObj, artifacts);
+    return {
+      code,
+      map: JSON.stringify(map)
+    };
+  };
+}
+//# sourceMappingURL=serializerCompose.js.map

package/lib/commonjs/pipeline/dispatcher/dispatcher.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Dispatcher = void 0;
+var _memoryQueue = require("../queue/memoryQueue");
+var _internalLogger = require("../../core/logger/internalLogger");
+class Dispatcher {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async flush() {
+    const batch = _memoryQueue.memoryQueue.popBatch();
+    if (batch.length === 0) return;
+    try {
+      await this.transport(batch);
+      __DEV__ && _internalLogger.logger.info(`Successfully dispatched batch of ${batch.length} events`);
+    } catch (err) {
+      _internalLogger.logger.error('Failed to dispatch batch, returning to queue', err);
+      // Re-queue items on failure
+      batch.forEach(env => _memoryQueue.memoryQueue.add(env));
+      throw err;
+    }
+  }
+}
+exports.Dispatcher = Dispatcher;
+//# sourceMappingURL=dispatcher.js.map

package/lib/commonjs/pipeline/envelope/envelope.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEnvelope = createEnvelope;
+function createEnvelope(type, payload) {
+  return {
+    id: Math.random().toString(36).substring(7),
+    type,
+    timestamp: Date.now(),
+    payload
+  };
+}
+
+// Re-export event types from contracts for consumers migrating to new import paths
+//# sourceMappingURL=envelope.js.map

package/lib/commonjs/pipeline/envelope/serializer.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeEnvelope = serializeEnvelope;
+function serializeEnvelope(envelope) {
+  const body = JSON.stringify(envelope);
+  return {
+    body,
+    size: body.length // Rough estimation in bytes
+  };
+}
+//# sourceMappingURL=serializer.js.map

package/lib/commonjs/pipeline/processors/dedupe.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=dedupe.js.map

package/lib/commonjs/pipeline/processors/enrich.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.enrichProcessor = enrichProcessor;
+function enrichProcessor(envelope, context) {
+  return {
+    ...envelope,
+    common: {
+      ...envelope.common,
+      ...context
+    }
+  };
+}
+//# sourceMappingURL=enrich.js.map

package/lib/commonjs/pipeline/processors/sampling.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=sampling.js.map

package/lib/commonjs/pipeline/processors/sanitize.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitizeProcessor = sanitizeProcessor;
+const PII_KEYS = ['email', 'phone', 'password', 'token', 'secret'];
+function sanitizeProcessor(envelope) {
+  const sanitize = obj => {
+    if (!obj || typeof obj !== 'object') return obj;
+    const result = {
+      ...obj
+    };
+    for (const key of Object.keys(result)) {
+      if (PII_KEYS.includes(key.toLowerCase())) {
+        result[key] = '[REDACTED]';
+      } else if (typeof result[key] === 'object') {
+        result[key] = sanitize(result[key]);
+      }
+    }
+    return result;
+  };
+  return {
+    ...envelope,
+    payload: sanitize(envelope.payload)
+  };
+}
+//# sourceMappingURL=sanitize.js.map

package/lib/commonjs/pipeline/queue/flushQueue.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flushQueue = flushQueue;
+var _internalLogger = require("../../core/logger/internalLogger");
+var _errorClassification = require("../../core/logger/errorClassification");
+var _exponentialJitter = require("../../transport/backoff/exponentialJitter");
+var _endpoints = require("../../transport/http/endpoints");
+/** Outcome of a flush attempt — lets callers schedule retries / report status. */
+
+/**
+ * Guards against overlapping flushes for the same queue. The scheduler interval
+ * and a manual `flush()` can fire concurrently; running both would let two
+ * attempts return batches to the queue independently and churn ordering.
+ */
+const inFlight = new WeakSet();
+
+/** Per-queue count of consecutive recoverable failures, for backoff. */
+const failureStreak = new WeakMap();
+async function flushQueue(queue, httpClient, deviceId, headers) {
+  if (inFlight.has(queue)) {
+    __DEV__ && _internalLogger.logger.debug('[Flush] Skipped — a flush is already in progress');
+    return {
+      status: 'skipped',
+      batchSize: 0
+    };
+  }
+  const batch = queue.popBatch(50);
+  if (batch.length === 0) {
+    return {
+      status: 'empty',
+      batchSize: 0
+    };
+  }
+  inFlight.add(queue);
+  try {
+    const res = await httpClient.post(_endpoints.ENDPOINTS.EVENTS, {
+      deviceId,
+      events: batch
+    }, headers);
+
+    // Treat transient backend states (5xx / 429) as recoverable.
+    if (res.status >= 500 || res.status === 429) {
+      return handleRecoverable(queue, batch, undefined, res.status);
+    }
+
+    // Client errors (bad clientKey, bad payload) won't fix on retry — do NOT
+    // requeue (avoids an infinite loop) but surface clearly and actionably.
+    if (res.status >= 400) {
+      failureStreak.delete(queue);
+      const hint = res.status === 404 ? '- 404 = route not found at this URL (routing/base-URL or wrong lane), NOT auth\n' + '- apiBaseUrl points at the correct environment + path prefix\n' : res.status === 401 || res.status === 403 ? '- clientKey is valid and active (auth rejected)\n' : '- payload shape is accepted by this endpoint\n';
+      _internalLogger.logger.error('Events rejected by the ingestion endpoint — not retrying this batch.\n' + `HTTP ${res.status}. Check:\n` + hint + `Endpoint: ${_endpoints.ENDPOINTS.EVENTS}`);
+      return {
+        status: 'fatal',
+        batchSize: batch.length
+      };
+    }
+    failureStreak.delete(queue);
+    __DEV__ && _internalLogger.logger.info(`Successfully flushed ${batch.length} events`);
+    return {
+      status: 'flushed',
+      batchSize: batch.length
+    };
+  } catch (err) {
+    if ((0, _errorClassification.isRecoverableFlushError)(err)) {
+      return handleRecoverable(queue, batch, err);
+    }
+    return handleFatal(queue, batch, err);
+  } finally {
+    inFlight.delete(queue);
+  }
+}
+function handleRecoverable(queue, batch, err, status) {
+  // Return events to the FRONT of the queue, preserving order. No double send,
+  // no double redaction — requeueBatch re-inserts the exact popped envelopes.
+  queue.requeueBatch(batch);
+
+  // Clamp the streak: the backoff delay already saturates at its 30s cap well before
+  // this (2^5·1000 > 30000), so a higher count only risks unbounded integer growth.
+  // The batch is never dropped (no-data-loss contract) — only the retry cadence is bounded.
+  const attempt = Math.min((failureStreak.get(queue) ?? 0) + 1, 16);
+  failureStreak.set(queue, attempt);
+  const nextRetryMs = Math.round((0, _exponentialJitter.getDelayWithJitter)(attempt - 1));
+  const reason = (0, _errorClassification.describeErrorReason)(err, status);
+
+  // Recoverable failures are routine — never use console.error (would RedBox).
+  _internalLogger.logger.warn('Flush aborted; events returned to queue. Retrying later.\n' + `Reason: ${reason}\n` + `Endpoint: ${_endpoints.ENDPOINTS.EVENTS}\n` + `Queue size: ${queue.length()}\n` + `Retry attempt: ${attempt}\n` + `Next retry: ~${nextRetryMs}ms`);
+  return {
+    status: 'recoverable',
+    batchSize: batch.length,
+    nextRetryMs
+  };
+}
+function handleFatal(queue, batch, err) {
+  // Even fatal errors keep the events — never silently drop user data.
+  queue.requeueBatch(batch);
+
+  // Genuinely unexpected / actionable: surface clearly for the host developer.
+  _internalLogger.logger.error('Events could not be flushed due to an unexpected error.\n' + 'Check:\n' + '- clientKey\n' + '- apiBaseUrl\n' + '- backend server status\n' + '- CORS / SSL / local dev proxy\n' + `Endpoint: ${_endpoints.ENDPOINTS.EVENTS}`, err);
+  return {
+    status: 'fatal',
+    batchSize: batch.length
+  };
+}
+//# sourceMappingURL=flushQueue.js.map