@scalebun-release/react-native 2.5.0

package/lib/module/core/context/device.js

@@ -0,0 +1,143 @@
+/**
+ * The ONE place that answers "what device is this?".
+ *
+ * It was previously answered three incompatible ways at once:
+ *
+ *   1. The replay lane asked the native bridge and got the truth.
+ *   2. The analytics lane took `ScaleBun.init({ context })` verbatim and shipped whatever the
+ *      integrator typed. Production carries `device_model: "android"`, `manufacturer: "android"`
+ *      and `sdk_version: "qa-app-1.0"` because an app hand-wrote them — none of those are a model,
+ *      a manufacturer, or an SDK version.
+ *   3. Seven call sites wrote `Platform.OS === 'ios' ? 'ios' : 'android'`, which reports every
+ *      non-iOS platform — windows, macos, web — as Android.
+ *
+ * Detection belongs to the SDK. An integrator cannot be expected to know the device better than the
+ * process running on it, and asking them to means the field is wrong whenever they guess.
+ *
+ * Every value here is measured or absent. Nothing is defaulted to a plausible-looking constant: a
+ * fabricated device model is indistinguishable from a real one to whoever reads the dashboard, which
+ * is strictly worse than an empty field.
+ */
+import { SDK_VERSION } from '../constants/version';
+
+/**
+ * The real `Platform.OS`, never narrowed.
+ *
+ * React Native's own union is `'ios' | 'android' | 'windows' | 'macos' | 'web'`, and the protocol's
+ * platform field is an open enum precisely so new ones travel without a release. Collapsing that to
+ * a two-way ternary is what made every macOS and Windows session read as Android.
+ */
+
+function rnPlatform() {
+  try {
+    return require('react-native').Platform ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `Platform.OS`, verbatim.
+ *
+ * `'unknown'` when React Native itself cannot be loaded — the previous `catch { return 'android' }`
+ * turned "we could not tell" into a confident, wrong answer.
+ */
+export function resolvePlatformOS() {
+  const os = rnPlatform()?.OS;
+  switch (os) {
+    case 'ios':
+    case 'android':
+    case 'windows':
+    case 'macos':
+    case 'web':
+      return os;
+    default:
+      // A platform React Native gained after this build. Pass it through rather than guess —
+      // the wire's platform field is an open enum for exactly this case.
+      return os ?? 'unknown';
+  }
+}
+
+/**
+ * `'ios' | 'android'` for the few call sites whose payload genuinely only has those two, keeping the
+ * narrowing HONEST: `null` where it used to silently say Android.
+ */
+export function resolveMobileOS() {
+  const os = resolvePlatformOS();
+  return os === 'ios' || os === 'android' ? os : null;
+}
+
+/** The keys this module owns. An integrator-supplied value for any of them is overridden. */
+export const DETECTED_CONTEXT_KEYS = ['sdk_version', 'platform_os', 'os_version', 'device_model', 'manufacturer'];
+
+/**
+ * Everything derivable WITHOUT the native bridge, so the very first event already carries it.
+ *
+ * The bridge is async and may not be installed at all (Expo Go, an older native binary); waiting on
+ * it would leave the opening events of every session unattributed. `Platform.constants` is populated
+ * synchronously at startup and covers Android fully — iOS exposes no model there, which is why
+ * `device_model` stays absent on iOS until {@link nativeDeviceContext} fills it in.
+ */
+export function staticDeviceContext() {
+  const platform = rnPlatform();
+  const out = {
+    sdk_version: SDK_VERSION,
+    platform_os: resolvePlatformOS()
+  };
+  if (!platform) return out;
+  const c = platform.constants ?? {};
+  // Android: Release is the marketing version ("14"); Version is the API level (34).
+  // iOS: osVersion is the real thing; Platform.Version mirrors it.
+  const osVersion = c.Release ?? c.osVersion ?? (platform.Version != null ? String(platform.Version) : undefined);
+  if (osVersion) out.os_version = String(osVersion);
+  if (c.Model) out.device_model = String(c.Model);
+  if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);else if (c.Brand) out.manufacturer = String(c.Brand);
+  // iOS exposes no manufacturer because it does not need to: every device running iOS is Apple's.
+  // A tautology, not a guess — and it means the field is populated on event #1 rather than waiting
+  // for a bridge that may never answer.
+  else if (out.platform_os === 'ios') out.manufacturer = 'Apple';
+  return out;
+}
+
+/** Bridge values, once the native module answers. Absent keys stay absent. */
+export function nativeDeviceContext(info) {
+  const out = {};
+  if (!info) return out;
+  if (info.osVersion) out.os_version = info.osVersion;
+  if (info.deviceModel) out.device_model = info.deviceModel;
+  if (info.manufacturer) out.manufacturer = info.manufacturer;
+  return out;
+}
+
+/**
+ * Merge the integrator's context with what we detected — DETECTED WINS on the keys above.
+ *
+ * The inversion is deliberate. Config normally wins over defaults, but these are not defaults: they
+ * are measurements, and a measurement must not be overridable by a guess. Everything outside
+ * {@link DETECTED_CONTEXT_KEYS} — `language`, `timezone`, `network_type`, anything app-specific —
+ * is still the integrator's to set, untouched.
+ */
+export function mergeDeviceContext(configured, detected = staticDeviceContext()) {
+  return {
+    ...(configured ?? {}),
+    ...detected
+  };
+}
+
+/**
+ * The analytics envelope lane's platform value, AUTO-DETECTED.
+ *
+ * The init config's `platform` field was documented as "Default: react_native" — so every
+ * integration that did not hand-write `platform: 'ios' | 'android'` stamped the literal
+ * `react_native` on all its analytics events, and the dashboard's platform filters (which split
+ * ios/android) silently excluded them. Asking the developer for a value the runtime knows is an
+ * integration tax with a failure mode; `Platform.OS` answers it exactly.
+ *
+ * `react_native` remains only for the genuinely-unknown case (RN unloadable, or an OS the wire
+ * enum does not carry) — an honest "RN, platform untold" rather than a confident wrong answer.
+ */
+export function resolveEventPlatform() {
+  const os = resolvePlatformOS();
+  return os === 'ios' || os === 'android' || os === 'web' ? os : 'react_native';
+}
+//# sourceMappingURL=device.js.map

package/lib/module/core/context/session.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=session.js.map

package/lib/module/core/context/user.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=user.js.map

package/lib/module/core/contracts/IFeature.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=IFeature.js.map

package/lib/module/core/di/container.js

@@ -0,0 +1,22 @@
+export class Container {
+  services = new Map();
+  register(key, instance) {
+    this.services.set(key, instance);
+    return instance;
+  }
+  get(key) {
+    const service = this.services.get(key);
+    if (!service) {
+      throw new Error(`Service ${key} not found in container`);
+    }
+    return service;
+  }
+  has(key) {
+    return this.services.has(key);
+  }
+  clear() {
+    this.services.clear();
+  }
+}
+export const coreContainer = new Container();
+//# sourceMappingURL=container.js.map

package/lib/module/core/encoding/base64.js

@@ -0,0 +1,44 @@
+/**
+ * ScaleBun SDK — base64 → binary decode (RN-safe).
+ *
+ * Used by the object-storage upload paths (replay frames + engage attachments) to
+ * turn a base64 payload into real binary bytes for a presigned PUT. We deliberately
+ * do NOT use the `fetch('data:…').blob()` round-trip: under the new architecture
+ * that rejects with "Network request failed". RN's XHR accepts a `Uint8Array` body
+ * and transfers `.buffer` to native as binary, so a decoded byte array uploads
+ * faithfully.
+ */
+
+const B64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+/** Decode a base64 string (no data-URI prefix) into a Uint8Array of raw bytes. */
+export function base64ToBytes(base64) {
+  // Prefer the runtime decoder when present (Hermes ≥ RN 0.71 ships atob).
+  const g = globalThis;
+  if (typeof g.atob === 'function') {
+    const bin = g.atob(base64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i) & 0xff;
+    return out;
+  }
+  return decodeManual(base64);
+}
+function decodeManual(base64) {
+  const clean = base64.replace(/[^A-Za-z0-9+/=]/g, '');
+  const pad = clean.endsWith('==') ? 2 : clean.endsWith('=') ? 1 : 0;
+  const outLen = Math.floor(clean.length * 3 / 4) - pad;
+  const out = new Uint8Array(outLen);
+  let p = 0;
+  for (let i = 0; i < clean.length; i += 4) {
+    const c0 = B64_ALPHABET.indexOf(clean[i]);
+    const c1 = B64_ALPHABET.indexOf(clean[i + 1]);
+    const c2 = B64_ALPHABET.indexOf(clean[i + 2]);
+    const c3 = B64_ALPHABET.indexOf(clean[i + 3]);
+    const n = c0 << 18 | c1 << 12 | (c2 & 63) << 6 | c3 & 63;
+    if (p < outLen) out[p++] = n >> 16 & 0xff;
+    if (p < outLen) out[p++] = n >> 8 & 0xff;
+    if (p < outLen) out[p++] = n & 0xff;
+  }
+  return out;
+}
+//# sourceMappingURL=base64.js.map

package/lib/module/core/id/deviceId.js

@@ -0,0 +1,45 @@
+import { noThrow } from '../lifecycle/crashSafe';
+import { createStorageBackend } from '../../storage/StorageBackend';
+const STORAGE_KEY = 'scalebun_device_id';
+const storage = createStorageBackend();
+let cachedDeviceId = null;
+
+/**
+ * Generates or retrieves a unique device ID.
+ */
+export function getDeviceId() {
+  if (cachedDeviceId) {
+    return cachedDeviceId;
+  }
+  try {
+    const stored = storage.get(STORAGE_KEY);
+    if (stored) {
+      cachedDeviceId = stored;
+      return stored;
+    }
+  } catch {
+    // Fallback if storage fails
+  }
+  const newId = noThrow(() => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+      const r = Math.random() * 16 | 0;
+      const v = c === 'x' ? r : r & 0x3 | 0x8;
+      return v.toString(16);
+    });
+  }, 'unknown-device-id') || 'unknown-device-id';
+  cachedDeviceId = newId;
+  try {
+    storage.set(STORAGE_KEY, newId);
+  } catch {
+    // Fallback if storage fails
+  }
+  return newId;
+}
+
+/**
+ * Generates a unique session ID.
+ */
+export function generateSessionId() {
+  return 'ses-' + getDeviceId() + '-' + Date.now().toString(36);
+}
+//# sourceMappingURL=deviceId.js.map

package/lib/module/core/id/installationId.js

@@ -0,0 +1,50 @@
+import { createStorageBackend } from '../../storage/StorageBackend';
+import { K_INSTALLATION_ID } from '../../analytics/EventTracker';
+
+/**
+ * The SDK's canonical per-install id.
+ *
+ * ONE install, ONE id, every lane. This is deliberately NOT `getDeviceId()` —
+ * that is a separate value under a separate storage key, and the backend schema
+ * annotates the two as different ("stable per-install id from the SDK (≠
+ * deviceId)").
+ *
+ * It matters because the backend joins a bundle's OTA installs to that device's
+ * sessions through this value. OTA events have always been keyed by it; the
+ * session lane did not send it at all, so on the server the two could only be
+ * connected for devices that happened to have registered for push. Release
+ * health then reported "no data" for bundles that were running perfectly well —
+ * or crashing badly.
+ *
+ * Lives here rather than inside one feature so the OTA orchestrator and the
+ * session adapter cannot drift to two different ids.
+ */
+export function resolveInstallationId() {
+  try {
+    const storage = createStorageBackend();
+    const existing = storage.get(K_INSTALLATION_ID);
+    if (existing) return existing;
+    const id = `inst-${randomSegment()}${randomSegment()}`;
+    storage.set(K_INSTALLATION_ID, id);
+    return id;
+  } catch {
+    // Storage unavailable (tests, exotic hosts): a per-process id keeps the
+    // lanes functional; it stabilizes on the first run where storage works.
+    return `inst-ephemeral-${randomSegment()}`;
+  }
+}
+
+/** 8 chars of base36 entropy, crypto-backed when the runtime offers it. */
+function randomSegment() {
+  try {
+    const g = globalThis;
+    if (g.crypto?.getRandomValues) {
+      const bytes = g.crypto.getRandomValues(new Uint8Array(6));
+      return Array.from(bytes).map(b => b.toString(36).padStart(2, '0')).join('').slice(0, 8);
+    }
+  } catch {
+    // fall through to Math.random
+  }
+  return Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+}
+//# sourceMappingURL=installationId.js.map

package/lib/module/core/id/sessionId.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=sessionId.js.map

package/lib/module/core/lifecycle/appLifecycle.js

@@ -0,0 +1,25 @@
+import { AppState } from 'react-native';
+import { logger } from '../logger/internalLogger';
+class AppLifecycle {
+  listeners = [];
+  currentState = AppState.currentState;
+  constructor() {
+    AppState.addEventListener('change', this.handleStateChange);
+  }
+  handleStateChange = nextState => {
+    __DEV__ && logger.debug(`App state changed: ${this.currentState} -> ${nextState}`);
+    this.currentState = nextState;
+    this.listeners.forEach(l => l(nextState));
+  };
+  addListener(listener) {
+    this.listeners.push(listener);
+  }
+  removeListener(listener) {
+    this.listeners = this.listeners.filter(l => l !== listener);
+  }
+  getCurrentState() {
+    return this.currentState;
+  }
+}
+export const appLifecycle = new AppLifecycle();
+//# sourceMappingURL=appLifecycle.js.map

package/lib/module/core/lifecycle/crashSafe.js

@@ -0,0 +1,26 @@
+/**
+ * Crash safety utilities for the SDK.
+ * Ensures that internal SDK failures do not crash the host application.
+ */
+
+export function noThrow(fn, fallback) {
+  try {
+    return fn();
+  } catch (error) {
+    if (__DEV__) {
+      console.warn('[ScaleBun] Internal non-fatal error:', error);
+    }
+    return fallback;
+  }
+}
+export async function safeAsync(fn, fallback) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (__DEV__) {
+      console.warn('[ScaleBun] Internal async error:', error);
+    }
+    return fallback;
+  }
+}
+//# sourceMappingURL=crashSafe.js.map

package/lib/module/core/logger/errorClassification.js

@@ -0,0 +1,96 @@
+/**
+ * ScaleBun SDK — Error Classification
+ *
+ * Pure helpers that classify transport/flush failures so the SDK can decide
+ * whether an error is a normal, recoverable condition (request aborted,
+ * timeout, offline, backend temporarily down) or a genuine fatal integration
+ * bug that the host developer must act on.
+ *
+ * Recoverable errors MUST NOT be logged through `console.error` — in React
+ * Native that triggers a LogBox / RedBox overlay for what is really a routine
+ * retry. See `internalLogger` for how levels map to console methods.
+ */
+
+/** Reason codes describing why a flush/transport attempt failed. */
+
+function nameOf(error) {
+  if (error && typeof error === 'object' && 'name' in error) {
+    return String(error.name ?? '');
+  }
+  return '';
+}
+function messageOf(error) {
+  if (error && typeof error === 'object' && 'message' in error) {
+    return String(error.message ?? '');
+  }
+  return typeof error === 'string' ? error : '';
+}
+
+/**
+ * AbortError — the request was cancelled via an AbortController. This happens
+ * on intentional cancel, app backgrounding, navigation interruption, or a
+ * timeout that aborts the underlying fetch.
+ */
+export function isAbortError(error) {
+  if (nameOf(error) === 'AbortError') return true;
+  // Some RN/fetch polyfills surface aborts only via message text.
+  return /\baborted\b/i.test(messageOf(error));
+}
+
+/** Timeout — the SDK aborted the request because it exceeded the deadline. */
+export function isTimeoutError(error) {
+  if (nameOf(error) === 'TimeoutError') return true;
+  if (error && typeof error === 'object' && error.isTimeout === true) {
+    return true;
+  }
+  return /\btimed?\s*out\b/i.test(messageOf(error));
+}
+
+/**
+ * Network error — device offline or the backend host is unreachable. RN's
+ * fetch rejects with a generic `TypeError: Network request failed`.
+ */
+export function isNetworkError(error) {
+  const msg = messageOf(error).toLowerCase();
+  return nameOf(error) === 'NetworkError' || msg.includes('network request failed') || msg.includes('failed to fetch') || msg.includes('network error') || msg.includes('connection') && msg.includes('refused');
+}
+
+/**
+ * Recoverable flush error — the events were not delivered but can safely be
+ * returned to the queue and retried later. Covers abort, timeout, offline,
+ * and transient backend unavailability (HTTP 5xx / 429).
+ *
+ * `status` is the HTTP status when the transport returned a response (used to
+ * treat 5xx and 429 as recoverable).
+ */
+export function isRecoverableFlushError(error, status) {
+  if (isAbortError(error) || isTimeoutError(error) || isNetworkError(error)) {
+    return true;
+  }
+  if (typeof status === 'number' && (status >= 500 || status === 429)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Fatal SDK error — not recoverable by retrying. Today this means anything we
+ * could not classify as recoverable. Used to decide whether to surface via
+ * `console.error`. Callers may pass a known HTTP `status` to keep client
+ * errors (4xx, except 429) classified as fatal/actionable.
+ */
+export function isFatalSdkError(error, status) {
+  return !isRecoverableFlushError(error, status);
+}
+
+/** Human-readable reason code for logs and internal status. */
+export function describeErrorReason(error, status) {
+  if (isTimeoutError(error)) return 'timeout';
+  if (isAbortError(error)) return 'request_aborted';
+  if (isNetworkError(error)) return 'offline';
+  if (typeof status === 'number' && (status >= 500 || status === 429)) {
+    return 'server_error';
+  }
+  return 'unknown';
+}
+//# sourceMappingURL=errorClassification.js.map

package/lib/module/core/logger/internalLogger.js

@@ -0,0 +1,59 @@
+export let LogLevel = /*#__PURE__*/function (LogLevel) {
+  LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+  LogLevel[LogLevel["INFO"] = 1] = "INFO";
+  LogLevel[LogLevel["WARN"] = 2] = "WARN";
+  LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+  LogLevel[LogLevel["NONE"] = 4] = "NONE";
+  return LogLevel;
+}({});
+
+/** Public, string-based log level used in SDK init config. */
+
+const LEVEL_BY_NAME = {
+  silent: LogLevel.NONE,
+  error: LogLevel.ERROR,
+  warn: LogLevel.WARN,
+  info: LogLevel.INFO,
+  debug: LogLevel.DEBUG
+};
+class InternalLogger {
+  level = LogLevel.WARN;
+  setLevel(level) {
+    this.level = level;
+  }
+
+  /** Set level from the public string name used in config (e.g. 'warn'). */
+  setLevelByName(name) {
+    const resolved = LEVEL_BY_NAME[name];
+    if (resolved !== undefined) {
+      this.level = resolved;
+    }
+  }
+
+  /** Current numeric level — exposed for callers that branch on dev verbosity. */
+  getLevel() {
+    return this.level;
+  }
+  debug(...args) {
+    if (this.level <= LogLevel.DEBUG) {
+      console.debug('[ScaleBun:Debug]', ...args);
+    }
+  }
+  info(...args) {
+    if (this.level <= LogLevel.INFO) {
+      console.info('[ScaleBun:Info]', ...args);
+    }
+  }
+  warn(...args) {
+    if (this.level <= LogLevel.WARN) {
+      console.warn('[ScaleBun:Warn]', ...args);
+    }
+  }
+  error(...args) {
+    if (this.level <= LogLevel.ERROR) {
+      console.error('[ScaleBun:Error]', ...args);
+    }
+  }
+}
+export const logger = new InternalLogger();
+//# sourceMappingURL=internalLogger.js.map

package/lib/module/core/logger/levels.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=levels.js.map

package/lib/module/crypto/hmacSha256.js

@@ -0,0 +1,126 @@
+/**
+ * Pure-JS HMAC-SHA256 (Phase 5.4) — no native module, so it runs identically on the
+ * Old and New RN architectures and in Node. Output matches Node's
+ * `crypto.createHmac('sha256', key).update(msg).digest('hex')` (asserted in tests).
+ *
+ * Used to sign the /batch envelope so the backend can tamper-detect the payload.
+ */
+
+const K = new Uint32Array([0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]);
+const rotr = (x, n) => x >>> n | x << 32 - n;
+
+/** Manual UTF-8 encode (no TextEncoder dependency — matches Node's utf8 byte output). */
+function utf8(str) {
+  const out = [];
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 0x80) out.push(c);else if (c < 0x800) out.push(0xc0 | c >> 6, 0x80 | c & 0x3f);else if (c >= 0xd800 && c <= 0xdbff) {
+      const c2 = str.charCodeAt(++i);
+      const cp = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+      out.push(0xf0 | cp >> 18, 0x80 | cp >> 12 & 0x3f, 0x80 | cp >> 6 & 0x3f, 0x80 | cp & 0x3f);
+    } else {
+      out.push(0xe0 | c >> 12, 0x80 | c >> 6 & 0x3f, 0x80 | c & 0x3f);
+    }
+  }
+  return new Uint8Array(out);
+}
+function sha256(msg) {
+  const H = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+  const l = msg.length;
+  const bitLen = l * 8;
+  const withOne = l + 1;
+  const pad = (56 - withOne % 64 + 64) % 64;
+  const total = withOne + pad + 8;
+  const m = new Uint8Array(total);
+  m.set(msg);
+  m[l] = 0x80;
+  const hi = Math.floor(bitLen / 0x100000000);
+  const lo = bitLen >>> 0;
+  m[total - 8] = hi >>> 24 & 0xff;
+  m[total - 7] = hi >>> 16 & 0xff;
+  m[total - 6] = hi >>> 8 & 0xff;
+  m[total - 5] = hi & 0xff;
+  m[total - 4] = lo >>> 24 & 0xff;
+  m[total - 3] = lo >>> 16 & 0xff;
+  m[total - 2] = lo >>> 8 & 0xff;
+  m[total - 1] = lo & 0xff;
+  const w = new Uint32Array(64);
+  for (let off = 0; off < total; off += 64) {
+    for (let i = 0; i < 16; i++) {
+      w[i] = (m[off + i * 4] << 24 | m[off + i * 4 + 1] << 16 | m[off + i * 4 + 2] << 8 | m[off + i * 4 + 3]) >>> 0;
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = H[0],
+      b = H[1],
+      c = H[2],
+      d = H[3],
+      e = H[4],
+      f = H[5],
+      g = H[6],
+      h = H[7];
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const t1 = h + S1 + ch + K[i] + w[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    H[0] = H[0] + a >>> 0;
+    H[1] = H[1] + b >>> 0;
+    H[2] = H[2] + c >>> 0;
+    H[3] = H[3] + d >>> 0;
+    H[4] = H[4] + e >>> 0;
+    H[5] = H[5] + f >>> 0;
+    H[6] = H[6] + g >>> 0;
+    H[7] = H[7] + h >>> 0;
+  }
+  const out = new Uint8Array(32);
+  for (let i = 0; i < 8; i++) {
+    out[i * 4] = H[i] >>> 24 & 0xff;
+    out[i * 4 + 1] = H[i] >>> 16 & 0xff;
+    out[i * 4 + 2] = H[i] >>> 8 & 0xff;
+    out[i * 4 + 3] = H[i] & 0xff;
+  }
+  return out;
+}
+function concat(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a);
+  out.set(b, a.length);
+  return out;
+}
+function toHex(bytes) {
+  let s = '';
+  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, '0');
+  return s;
+}
+
+/** HMAC-SHA256(key, message) → lowercase hex. */
+export function hmacSha256Hex(key, message) {
+  let k = utf8(key);
+  if (k.length > 64) k = sha256(k);
+  const block = new Uint8Array(64);
+  block.set(k);
+  const ipad = new Uint8Array(64);
+  const opad = new Uint8Array(64);
+  for (let i = 0; i < 64; i++) {
+    ipad[i] = block[i] ^ 0x36;
+    opad[i] = block[i] ^ 0x5c;
+  }
+  const inner = sha256(concat(ipad, utf8(message)));
+  return toHex(sha256(concat(opad, inner)));
+}
+//# sourceMappingURL=hmacSha256.js.map