@allstak/react 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to `@allstak/react` are documented in this file.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.1] — 2026-05-11
+
+### Fixed
+
+- Version constant in `client.ts` now matches `package.json` (was `0.3.0`).
+- Added version consistency test to CI.
+
+## [0.3.0] — 2026-05-08
+
+### Added
+
+- Full automatic HTTP instrumentation (fetch and XHR interception).
+- Source map upload pipeline with Vite, Webpack, and Next.js build plugins.
+- Per-frame `debugId` resolution via `globalThis._allstakDebugIds`.
+- `debugMeta.images[]` aggregation in error payloads.
+
+## [0.2.0] — 2026-04-25
+
+### Added
+
+- Scope management for tags, extras, and context.
+- Distributed tracing with automatic `traceparent` propagation.
+- Web session replay (surrogate events).
+- React Router integration helpers.
+- Debug-ID based source map resolution.
+
+## [0.1.4] — 2026-04-10
+
+### Changed
+
+- Standalone release on public npm as `@allstak/react`.
+
+### Added
+
+- `ErrorBoundary` component with `componentDidCatch` capture.
+- Automatic `window.onerror` and `onunhandledrejection` handlers.
+- `beforeSend` callback, `sampleRate`, `setTags`/`setExtra`/`setContext`.
+- `flush()` with bounded timeout.
+- Web Vitals (LCP, FID, CLS) capture.
+
+## [0.1.1] — 2026-03-28
+
+Initial professional release.
+
+### Added
+
+- Core error capture with stack trace parsing.
+- Breadcrumb ring buffer (max 50).
+- Fail-open transport with exponential backoff.
+- Circuit breaker on 401 responses.

package/README.md

@@ -1,12 +1,12 @@
 # @allstak/react
 
-**Drop-in error tracking for React. One `<AllStakErrorBoundary>`, zero config beyond your API key.**
+**One wrapper. Full error tracking + Web Vitals + breadcrumbs + HTTP. For React 17, 18, and 19.**
 
 [![npm version](https://img.shields.io/npm/v/@allstak/react.svg)](https://www.npmjs.com/package/@allstak/react)
 [![CI](https://github.com/AllStak/allstak-react/actions/workflows/ci.yml/badge.svg)](https://github.com/AllStak/allstak-react/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Official AllStak SDK for React — error boundary component, hooks, and a profiler HOC on top of the browser SDK.
+Official AllStak SDK for React — provider component, error boundary, hooks, and Web Vitals on top of a self-contained browser client.
 
 ## Dashboard
 
@@ -16,42 +16,139 @@ View captured events live at [app.allstak.sa](https://app.allstak.sa).
 
 ## Features
 
-- `<AllStakErrorBoundary>` component for render-tree error capture
-- `useAllStak()` hook for in-component capture and context
-- `withAllStakProfiler` HOC for mount/update timing
-- Inherits automatic fetch, console, and window error capture from the core SDK
-- Works with React 17, 18, and 19
+- **One-wrapper setup** — `<AllStakProvider>` initializes everything
+- React error boundary with custom fallback UI + `resetError`
+- `window.onerror` + `unhandledrejection` capture
+- `console.warn` + `console.error` capture by default; `log`/`info` opt-in
+- `fetch` and `XMLHttpRequest` breadcrumbs (200 / 4xx / 5xx / network failure)
+- Full HTTP request events with `enableHttpTracking: true` + privacy-first redaction
+- Auto navigation breadcrumbs (history.pushState patch + popstate)
+- Web Vitals via PerformanceObserver (CLS / LCP / INP / FCP / TTFB)
+- React Router + Next.js helpers
+- `useAllStak()` hook with stable identity
 - Full TypeScript types
 
-## What You Get
-
-Once integrated, every event flows to your AllStak dashboard:
+## Quick Start
 
-- **Errors** — render-tree crashes, caught hook errors, stack traces with component names
-- **Logs** — console warnings and errors as structured breadcrumbs
-- **HTTP** — outbound `fetch` timing, status codes, failed calls
-- **Performance** — mount and update timing from the profiler HOC
-- **Alerts** — email and webhook notifications on regressions
+> **Time to first event: under 2 minutes.**
+> Create a project at [app.allstak.sa](https://app.allstak.sa) to get your API key.
 
-## Installation
+### 1. Install
 
 ```bash
 npm install @allstak/react
 ```
 
-## Quick Start
+### 2. Wrap your app
 
-> Create a project at [app.allstak.sa](https://app.allstak.sa) to get your API key.
+```tsx
+import { AllStakProvider } from '@allstak/react';
+
+export function App() {
+  return (
+    <AllStakProvider
+      apiKey="ask_live_YOUR_KEY_HERE"
+      environment="production"
+      release="web@1.0.0"
+      debug
+    >
+      <AppRoot />
+    </AllStakProvider>
+  );
+}
+```
+
+### 3. Trigger a test error
 
 ```tsx
+import { AllStak } from '@allstak/react';
+
+// On a button press or on mount:
+AllStak.captureException(new Error('test: hello from allstak-react'));
+```
+
+### 4. Check your dashboard
+
+Open [app.allstak.sa](https://app.allstak.sa) — the error appears within seconds.
+
+When `debug` is enabled you'll see `[AllStak] Initialized — session <id>` and `[AllStak] Navigation auto-instrumentation enabled` in your browser console.
+
+`AllStakProvider` handles everything:
+- Initializes the SDK
+- Wraps your app in an `AllStakErrorBoundary`
+- Hooks `window.onerror`, `unhandledrejection`, `console.*`, `fetch`, `history.*`
+- Starts Web Vitals collection
+- Tags every event with `platform: 'browser'`, sdk name + version
+
+## Automatic Capture Matrix
+
+Status legend:
+- ✅ **Auto by default** — works the moment the provider mounts
+- ⚙️ **Auto when enabled by config** — set the listed prop
+- 🛠 **Manual only** — call the listed function yourself
+- 🟡 **Implemented but not browser-verified end-to-end yet**
+- ❌ **Not supported yet** (roadmap)
+
+| Capability | Status | Config / API | Wire form |
+|---|---|---|---|
+| Render errors via `<AllStakProvider>` boundary | ✅ | always-on inside the provider | `POST /ingest/v1/errors` with `metadata.source = 'AllStakProvider.ErrorBoundary'` + `componentStack` |
+| `window.onerror` global handler | ✅ | `autoCaptureBrowserErrors` (default `true`) | `POST /ingest/v1/errors` with `metadata.source = 'window.onerror'` |
+| `window.unhandledrejection` | ✅ | `autoCaptureBrowserErrors` | `POST /ingest/v1/errors` with `metadata.source = 'window.unhandledrejection'` |
+| Manual `AllStak.captureException` | 🛠 | `AllStak.captureException(err, ctx?)` | `POST /ingest/v1/errors` |
+| Manual `AllStak.captureMessage` | 🛠 | `AllStak.captureMessage(msg, level)` | `/ingest/v1/logs` (`info`/`warn`); both `errors` + `logs` for `error`/`fatal` |
+| `console.warn` / `console.error` | ✅ | `autoBreadcrumbsConsole` (default `true`); per-method via `captureConsole={ warn: true, error: true }` | `breadcrumb` of `type: 'log'`, `level: 'warn'` / `'error'`, `data.category: 'console'` |
+| `console.log` / `console.info` | ⚙️ | `captureConsole={{ log: true, info: true }}` (default `false` to avoid spam) | `breadcrumb` of `type: 'log'`, `level: 'info'`, `data.method: 'log'` / `'info'` |
+| HTTP `fetch` breadcrumbs (success) | ✅ | `autoBreadcrumbsFetch` (default `true`) | `breadcrumb` of `type: 'http'`, `level: 'info'` |
+| HTTP `fetch` 4xx / 5xx breadcrumbs | ✅ | `autoBreadcrumbsFetch` | `breadcrumb` of `type: 'http'`, `level: 'error'` when status ≥ 400 |
+| HTTP `fetch` network failure | ✅ | `autoBreadcrumbsFetch` | `breadcrumb` with `data.error`; original error rethrown |
+| HTTP `XMLHttpRequest` breadcrumbs | ✅ | `enableHttpTracking` (also covers fetch full events) | breadcrumb same shape |
+| Full HTTP request events (method / URL / headers / body) | ⚙️ | `enableHttpTracking: true` (default `false`); `httpTracking: { ... }` for redaction control | `POST /ingest/v1/http-requests` |
+| Recent failed HTTP attached to next exception | ⚙️ | `enableHttpTracking: true` | `metadata['http.recentFailed']` (last 5 failed requests) |
+| Auto navigation breadcrumbs (pushState / popstate) | ✅ | `autoBreadcrumbsNavigation` (default `true`) | `breadcrumb` of `type: 'navigation'`, `data.from`/`data.to` |
+| React Router integration | 🛠 | `instrumentReactRouter(useLocation())` in a `useEffect` | same shape |
+| Next.js Pages Router | 🛠 | `instrumentNextRouter(url)` from `Router.events.on('routeChangeComplete')` | same shape |
+| **Web Vitals (CLS / LCP / INP / FCP / TTFB)** | ✅ | `autoWebVitals` (default `true`) | `POST /ingest/v1/logs` with `metadata.category = 'web-vital'`, `metadata.name`, `metadata.value` |
+| User context | 🛠 | `AllStak.setUser({ id, email })` | `payload.user` |
+| Custom tags / extras / contexts | 🛠 | `AllStak.setTag` / `setExtra` / `setContext` | `payload.metadata.<key>` |
+| `release`, `environment`, `dist` | 🛠 via init | `<AllStakProvider release="web@1.0.0">` etc. | top-level fields on every payload |
+| Source maps | 🛠 build-time | `@allstak/js/sourcemaps` plugin (Vite / Webpack / Next) | injected `debugId` per chunk |
+| Session replay (DOM-mutation) | ⚙️ | `replay={ sampleRate: 0.1, maskAllInputs: true }` (default OFF) | `POST /ingest/v1/replay` |
+| Offline event queue (in-memory only — see roadmap) | ✅ | n/a; configured via transport (max 100 in-RAM, drops oldest) | retried on next successful send; lost on page navigation |
+
+### Roadmap
+
+- Persistent offline queue (currently RAM-only; lost on page navigation)
+- React Query / SWR breadcrumbs
+- Vue / Svelte / Solid sister packages
+
+## Verification status
+
+The capabilities marked ✅ in the matrix above were verified live in
+Chrome against the SDK's own wire format (see
+[docs/reports/react-sdk-production-readiness.md](docs/reports/react-sdk-production-readiness.md)
+for command-by-command details). 156 error events, 84 logs (including
+5 web vitals), 9 full HTTP events, and a working render-error → fallback
+→ resetError → recovery cycle were all observed end-to-end.
+
+The live-backend round-trip is documented in the report. The wire format
+is identical to `@allstak/react-native`, which was fully round-trip
+verified against the same backend in
+`../../allstak-react-native/docs/reports/react-native-backend-ingestion-verification.md`.
+
+## Manual setup (advanced)
+
+If you need full control over initialization order, you can skip
+`AllStakProvider` and set up manually:
+
+```ts
 import { AllStak, AllStakErrorBoundary } from '@allstak/react';
 
 AllStak.init({
-  apiKey: import.meta.env.VITE_ALLSTAK_API_KEY,
+  apiKey: 'ask_live_…',
   environment: 'production',
 });
 
-AllStak.captureException(new Error('test: hello from allstak-react'));
+AllStak.captureException(new Error('test'));
 
 export function App() {
   return (
@@ -62,8 +159,6 @@ export function App() {
 }
 ```
 
-Load the app — the test error appears in your dashboard within seconds.
-
 ## Get Your API Key
 
 1. Sign up at [app.allstak.sa](https://app.allstak.sa)
@@ -104,7 +199,7 @@ Wrap a component with the profiler:
 
 ```tsx
 import { withAllStakProfiler } from '@allstak/react';
-export default withAllStakProfiler(Dashboard, { name: 'Dashboard' });
+export default withAllStakProfiler(Dashboard, 'Dashboard');
 ```
 
 Set user context on login:
@@ -165,55 +260,126 @@ Production endpoint: `https://api.allstak.sa`. Override via `host` for self-host
 AllStak.init({ apiKey: '...', host: 'https://allstak.mycorp.com' });
 ```
 
-## Source maps
+## Source maps — automatic via build plugin
 
-Production stack traces are minified — to see real function names and
-line numbers in the AllStak dashboard you need to upload the source maps
-that your bundler emits. The CLI lives in `@allstak/js/sourcemaps`; you
-do **not** need to install `@allstak/js` as a runtime dependency, only
-as a `devDependency` for the build step.
+Production stack traces are minified. To see real function names and
+line numbers in the AllStak dashboard you need to upload your source
+maps. The build-time tooling ships **inside `@allstak/react` itself** —
+no extra package to install — and runs **automatically** as part of
+your normal build via the Vite / Webpack / Next.js plugin.
 
-### Vite
+The plugins inject a stable `debugId` into every chunk and (when a
+token is present) upload the matching `.map` to the AllStak ingest. The
+runtime resolver in `@allstak/react` reads `globalThis._allstakDebugIds`
+at capture time and attaches the right debug-id to each frame, so the
+symbolicator picks the correct map even after long-tail caching of
+bundles.
 
-```bash
-npm install -D @allstak/js
-```
+### Vite
 
 ```ts
 // vite.config.ts
 import { defineConfig } from 'vite';
-import { allstakSourcemaps } from '@allstak/js/vite';
+import react from '@vitejs/plugin-react';
+import { allstakSourcemaps } from '@allstak/react/vite';
 
 export default defineConfig({
-  build: { sourcemap: 'hidden' },
+  build: { sourcemap: true },
   plugins: [
+    react(),
     allstakSourcemaps({
-      release: process.env.RELEASE!,
+      release: process.env.ALLSTAK_RELEASE!,
       token: process.env.ALLSTAK_UPLOAD_TOKEN!,
+      dist: 'web',
     }),
   ],
 });
 ```
 
-### Webpack / Next / generic
+### Webpack
+
+```js
+// webpack.config.js
+const { AllStakWebpackPlugin } = require('@allstak/react/webpack');
+
+module.exports = {
+  devtool: 'source-map',
+  plugins: [
+    new AllStakWebpackPlugin({
+      release: process.env.ALLSTAK_RELEASE,
+      token: process.env.ALLSTAK_UPLOAD_TOKEN,
+      dist: 'web',
+    }),
+  ],
+};
+```
+
+### Next.js
+
+```js
+// next.config.js
+const { withAllStak } = require('@allstak/react/next');
+
+module.exports = withAllStak(
+  {
+    release: process.env.ALLSTAK_RELEASE,
+    token: process.env.ALLSTAK_UPLOAD_TOKEN,
+    dist: 'web',
+  },
+  {
+    reactStrictMode: true,
+    // …rest of your Next config…
+  }
+);
+```
+
+The `withAllStak` wrapper sets `productionBrowserSourceMaps: true` for
+you and only attaches the plugin to the client bundle (Node-side stack
+traces are already symbolicated).
 
-The plugin exists for `@allstak/js/webpack` and `@allstak/js/next`; for
-any other bundler call the underlying API after your build:
+### Other bundlers / programmatic use
 
 ```ts
-import { processBuildOutput } from '@allstak/js/sourcemaps';
+import { processBuildOutput } from '@allstak/react/sourcemaps';
 
 await processBuildOutput({
   dir: 'dist',
-  release: process.env.RELEASE!,
+  release: process.env.ALLSTAK_RELEASE!,
   token: process.env.ALLSTAK_UPLOAD_TOKEN!,
+  dist: 'web',
+});
+```
+
+### What gets sent
+
+Each map is POSTed as `multipart/form-data` to
+`POST /api/v1/artifacts/upload` with these fields:
+
+- `debugId` — UUID injected into the bundle and the map (matching across both)
+- `type` — `"sourcemap"` (and `"bundle"` if `uploadBundles: true`)
+- `release` — your release identifier (e.g. `web@1.4.2`)
+- `dist` — your distribution tag (e.g. `web`)
+- `file` — the map content as a Blob
+
+Auth uses `X-AllStak-Upload-Token` (a project-scoped upload token, NOT
+the runtime API key). Generate one in **Project Settings → Upload Tokens**.
+
+### Privacy
+
+By default the map is uploaded as-is, which includes embedded
+`sourcesContent`. To strip it (smaller payloads, no source code stored
+on AllStak's side), set `stripSources: true`:
+
+```ts
+allstakSourcemaps({
+  release: '…',
+  token: '…',
+  stripSources: true,
 });
 ```
 
-This injects a stable `debugId` into every chunk and uploads the matching
-`.map`. The runtime resolver in `@allstak/react` reads `globalThis._allstakDebugIds`
-to attach the right debug-id to each captured frame, so the symbolicator
-picks the correct map even after long-tail caching of bundles.
+The backend rejects uploads in privacy-mode projects when the map still
+contains `sourcesContent` — the SDK side surfaces a clear error.
 
 ## Links
 

package/dist/build/chunk-G6VPGDP6.mjs

@@ -0,0 +1,214 @@
+// src/build/walk.ts
+import { readdirSync, statSync } from "fs";
+import { basename, join } from "path";
+function walk(dir, out = []) {
+  for (const name of readdirSync(dir)) {
+    const full = join(dir, name);
+    const st = statSync(full);
+    if (st.isDirectory()) walk(full, out);
+    else out.push(full);
+  }
+  return out;
+}
+function findPairs(root) {
+  const all = walk(root);
+  const maps = new Set(all.filter((p) => p.endsWith(".map")));
+  const pairs = [];
+  for (const js of all) {
+    if (!js.endsWith(".js") && !js.endsWith(".mjs") && !js.endsWith(".cjs")) continue;
+    const map = js + ".map";
+    if (maps.has(map)) {
+      pairs.push({ jsPath: js, mapPath: map, bundleName: basename(js) });
+    }
+  }
+  return pairs;
+}
+
+// src/build/inject.ts
+import { readFileSync, writeFileSync } from "fs";
+import { randomUUID } from "crypto";
+var DEBUG_ID_LINE_RE = /^\/\/# debugId=([0-9a-f-]{36})\s*$/m;
+var REGISTRATION_MARKER = "/*!__allstak_debug_id_registration__*/";
+function buildRegistrationSnippet(jsBody, debugId) {
+  const isEsm = /\bimport\.meta\b/.test(jsBody) || /^\s*(?:import|export)\b/m.test(jsBody);
+  if (isEsm) {
+    return `${REGISTRATION_MARKER}try{(globalThis._allstakDebugIds=globalThis._allstakDebugIds||{})[import.meta.url]="${debugId}"}catch(_){}`;
+  }
+  return `${REGISTRATION_MARKER}(function(){try{var u=(typeof document!=="undefined"&&document.currentScript&&document.currentScript.src)||(typeof location!=="undefined"?location.href:"");(globalThis._allstakDebugIds=globalThis._allstakDebugIds||{})[u]="${debugId}"}catch(_){}})();`;
+}
+function stripRegistration(js) {
+  const lineRe = new RegExp(
+    "^" + REGISTRATION_MARKER.replace(/[/*!]/g, (c) => "\\" + c) + ".*$",
+    "m"
+  );
+  return js.replace(lineRe, "");
+}
+function injectPair(p) {
+  const jsRaw = readFileSync(p.jsPath, "utf8");
+  const mapRaw = readFileSync(p.mapPath, "utf8");
+  const map = JSON.parse(mapRaw);
+  let debugId = typeof map.debugId === "string" ? map.debugId : "";
+  const existing = DEBUG_ID_LINE_RE.exec(jsRaw);
+  if (existing && existing[1]) debugId = debugId || existing[1];
+  const reused = !!debugId;
+  if (!debugId) debugId = randomUUID();
+  map.debugId = debugId;
+  writeFileSync(p.mapPath, JSON.stringify(map));
+  let jsOut = stripRegistration(jsRaw.replace(DEBUG_ID_LINE_RE, ""));
+  jsOut = jsOut.replace(/\s+$/, "");
+  jsOut += `
+${buildRegistrationSnippet(jsOut, debugId)}
+//# debugId=${debugId}
+`;
+  writeFileSync(p.jsPath, jsOut);
+  return { debugId, reused };
+}
+function injectAll(pairs) {
+  return pairs.map((pair) => ({ pair, result: injectPair(pair) }));
+}
+function readDebugIdFromMap(mapPath) {
+  const json = JSON.parse(readFileSync(mapPath, "utf8"));
+  return typeof json.debugId === "string" ? json.debugId : null;
+}
+
+// src/build/upload.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename as basename2 } from "path";
+var DEFAULT_HOST = "https://api.allstak.sa";
+async function uploadOne(type, filePath, debugId, opts) {
+  let buf = readFileSync2(filePath);
+  if (type === "sourcemap" && opts.stripSources) {
+    const json = JSON.parse(buf.toString("utf8"));
+    if (Array.isArray(json.sourcesContent)) delete json.sourcesContent;
+    buf = Buffer.from(JSON.stringify(json));
+  }
+  const form = new FormData();
+  form.append("debugId", debugId);
+  form.append("type", type);
+  form.append("release", opts.release);
+  if (opts.dist) form.append("dist", opts.dist);
+  form.append(
+    "file",
+    new Blob([buf], {
+      type: type === "sourcemap" ? "application/json" : "application/javascript"
+    }),
+    basename2(filePath)
+  );
+  const res = await fetch(opts.host.replace(/\/$/, "") + "/api/v1/artifacts/upload", {
+    method: "POST",
+    headers: { "X-AllStak-Upload-Token": opts.token },
+    body: form
+  });
+  return { status: res.status, body: await res.text(), ok: res.ok };
+}
+function sha8(buf) {
+  let hash = 0;
+  for (let i = 0; i < buf.length; i++) hash = (hash << 5) - hash + buf[i] | 0;
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+async function uploadPair(p, opts) {
+  const debugId = readDebugIdFromMap(p.mapPath);
+  if (!debugId) {
+    return {
+      bundleName: p.bundleName,
+      debugId: "",
+      ok: false,
+      steps: [{
+        type: "sourcemap",
+        status: 0,
+        sha8: "",
+        body: `[allstak/upload] no debugId in ${p.mapPath} \u2014 run inject first`
+      }]
+    };
+  }
+  const merged = {
+    release: opts.release,
+    host: opts.host ?? process.env.ALLSTAK_HOST ?? DEFAULT_HOST,
+    token: opts.token,
+    dist: opts.dist,
+    stripSources: opts.stripSources
+  };
+  const steps = [];
+  const mapResult = await uploadOne("sourcemap", p.mapPath, debugId, merged);
+  steps.push({
+    type: "sourcemap",
+    status: mapResult.status,
+    sha8: sha8(readFileSync2(p.mapPath)),
+    body: mapResult.ok ? void 0 : mapResult.body
+  });
+  let allOk = mapResult.ok;
+  if (opts.uploadBundles) {
+    const bundleResult = await uploadOne("bundle", p.jsPath, debugId, merged);
+    steps.push({
+      type: "bundle",
+      status: bundleResult.status,
+      sha8: sha8(readFileSync2(p.jsPath)),
+      body: bundleResult.ok ? void 0 : bundleResult.body
+    });
+    allOk = allOk && bundleResult.ok;
+  }
+  return { bundleName: p.bundleName, debugId, ok: allOk, steps };
+}
+async function uploadAll(pairs, opts) {
+  return Promise.all(pairs.map((p) => uploadPair(p, opts)));
+}
+
+// src/build/sourcemaps.ts
+import { resolve } from "path";
+async function processBuildOutput(opts) {
+  const dir = resolve(opts.dir);
+  const pairs = findPairs(dir);
+  const log = opts.silent ? () => void 0 : (m) => console.log(`[allstak/sourcemaps] ${m}`);
+  log(`scanning ${dir} \u2014 ${pairs.length} bundle/map pair(s)`);
+  if (pairs.length === 0) {
+    return { dir, pairs: 0, injected: [] };
+  }
+  const injectedRaw = injectAll(pairs);
+  const injected = injectedRaw.map(({ pair, result }) => ({
+    bundleName: pair.bundleName,
+    debugId: result.debugId,
+    reused: result.reused
+  }));
+  for (const i of injected) {
+    log(`  ${i.bundleName}  ${i.debugId}  ${i.reused ? "(reused)" : "(new)"}`);
+  }
+  const token = opts.token ?? process.env.ALLSTAK_UPLOAD_TOKEN;
+  const release = opts.release ?? process.env.ALLSTAK_RELEASE;
+  if (opts.injectOnly || !token) {
+    if (!opts.injectOnly && !token) {
+      log("skipping upload \u2014 no token (set ALLSTAK_UPLOAD_TOKEN or pass `token`)");
+    }
+    return { dir, pairs: pairs.length, injected };
+  }
+  if (!release) {
+    log("skipping upload \u2014 no release (set ALLSTAK_RELEASE or pass `release`)");
+    return { dir, pairs: pairs.length, injected };
+  }
+  const uploaded = await uploadAll(pairs, {
+    ...opts,
+    release,
+    token
+  });
+  for (const u of uploaded) {
+    if (u.ok) {
+      log(`  ${u.bundleName}  uploaded debugId=${u.debugId}`);
+    } else {
+      const last = u.steps[u.steps.length - 1];
+      log(`  ${u.bundleName}  FAIL status=${last?.status ?? "?"} body=${last?.body ?? ""}`);
+    }
+  }
+  return { dir, pairs: pairs.length, injected, uploaded };
+}
+
+export {
+  walk,
+  findPairs,
+  injectPair,
+  injectAll,
+  readDebugIdFromMap,
+  DEFAULT_HOST,
+  uploadPair,
+  uploadAll,
+  processBuildOutput
+};
+//# sourceMappingURL=chunk-G6VPGDP6.mjs.map

package/dist/build/chunk-G6VPGDP6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/walk.ts","../../src/build/inject.ts","../../src/build/upload.ts","../../src/build/sourcemaps.ts"],"sourcesContent":["/**\n * Build-time only. File-system walking for the source-map pipeline.\n * Pure Node 18+ (built-in `node:fs` only). Browser runtime never imports\n * this — it's behind a `./build/*` subpath that's marked Node-platform.\n */\n\nimport { readdirSync, statSync } from 'node:fs';\nimport { basename, join } from 'node:path';\n\n/** A bundle and its companion source map on disk. */\nexport interface BundlePair {\n  /** Absolute path to the JS bundle (`.js` / `.mjs` / `.cjs`). */\n  jsPath: string;\n  /** Absolute path to the matching `.map` file. */\n  mapPath: string;\n  /** Bare filename of the bundle (no directory), for log lines. */\n  bundleName: string;\n}\n\n/** Recursively list every file under `dir`. Symlinks are followed. */\nexport function walk(dir: string, out: string[] = []): string[] {\n  for (const name of readdirSync(dir)) {\n    const full = join(dir, name);\n    const st = statSync(full);\n    if (st.isDirectory()) walk(full, out);\n    else out.push(full);\n  }\n  return out;\n}\n\n/**\n * Returns every `(bundle, sourcemap)` pair under `root`.\n *\n * A pair is a `.js` / `.mjs` / `.cjs` file with a sibling file of the\n * same name plus a `.map` suffix — the convention every modern bundler\n * (Vite, Webpack, esbuild, Rollup, tsup) follows.\n */\nexport function findPairs(root: string): BundlePair[] {\n  const all = walk(root);\n  const maps = new Set(all.filter((p) => p.endsWith('.map')));\n  const pairs: BundlePair[] = [];\n  for (const js of all) {\n    if (!js.endsWith('.js') && !js.endsWith('.mjs') && !js.endsWith('.cjs')) continue;\n    const map = js + '.map';\n    if (maps.has(map)) {\n      pairs.push({ jsPath: js, mapPath: map, bundleName: basename(js) });\n    }\n  }\n  return pairs;\n}\n","/**\n * Debug-ID injection. Build-time only.\n *\n * For each `(bundle.js, bundle.js.map)` pair we:\n *   - Generate a stable per-bundle UUID (one already on the bundle is\n *     reused so re-running is idempotent).\n *   - Append `//# debugId=<uuid>` to the JS so the runtime resolver in\n *     `src/debug-id.ts` can read it back.\n *   - Write a top-level `debugId` field into the `.map` JSON so the\n *     symbolicator on the backend can join `bundle.js` ↔ `bundle.js.map`\n *     by ID rather than guessing from filenames.\n *\n * Bundlers re-write hashed filenames on every build, so joining by ID\n * (instead of by URL or path) is what makes resolved stack frames\n * survive across releases.\n */\n\nimport { readFileSync, writeFileSync } from 'node:fs';\nimport { randomUUID } from 'node:crypto';\n\nimport type { BundlePair } from './walk';\n\nconst DEBUG_ID_LINE_RE = /^\\/\\/# debugId=([0-9a-f-]{36})\\s*$/m;\nconst REGISTRATION_MARKER = '/*!__allstak_debug_id_registration__*/';\n\nfunction buildRegistrationSnippet(jsBody: string, debugId: string): string {\n  const isEsm = /\\bimport\\.meta\\b/.test(jsBody) || /^\\s*(?:import|export)\\b/m.test(jsBody);\n  if (isEsm) {\n    return `${REGISTRATION_MARKER}try{(globalThis._allstakDebugIds=globalThis._allstakDebugIds||{})[import.meta.url]=\"${debugId}\"}catch(_){}`;\n  }\n  return `${REGISTRATION_MARKER}(function(){try{var u=(typeof document!==\"undefined\"&&document.currentScript&&document.currentScript.src)||(typeof location!==\"undefined\"?location.href:\"\");(globalThis._allstakDebugIds=globalThis._allstakDebugIds||{})[u]=\"${debugId}\"}catch(_){}})();`;\n}\n\nfunction stripRegistration(js: string): string {\n  const lineRe = new RegExp(\n    '^' + REGISTRATION_MARKER.replace(/[/*!]/g, (c) => '\\\\' + c) + '.*$',\n    'm',\n  );\n  return js.replace(lineRe, '');\n}\n\n/** Outcome of injecting one pair. */\nexport interface InjectResult {\n  /** UUID injected (or reused) for this bundle. */\n  debugId: string;\n  /** True if the bundle already had a debugId — we reused it. */\n  reused: boolean;\n}\n\n/**\n * Inject (or reuse) the debug ID for a single bundle/sourcemap pair.\n * Mutates both files on disk. Pure synchronous Node — safe to call from\n * a Vite `closeBundle` or Webpack `afterEmit` hook.\n */\nexport function injectPair(p: BundlePair): InjectResult {\n  const jsRaw = readFileSync(p.jsPath, 'utf8');\n  const mapRaw = readFileSync(p.mapPath, 'utf8');\n  const map = JSON.parse(mapRaw) as { debugId?: unknown; [k: string]: unknown };\n\n  let debugId = typeof map.debugId === 'string' ? map.debugId : '';\n  const existing = DEBUG_ID_LINE_RE.exec(jsRaw);\n  if (existing && existing[1]) debugId = debugId || existing[1];\n  const reused = !!debugId;\n  if (!debugId) debugId = randomUUID();\n\n  map.debugId = debugId;\n  writeFileSync(p.mapPath, JSON.stringify(map));\n\n  let jsOut = stripRegistration(jsRaw.replace(DEBUG_ID_LINE_RE, ''));\n  jsOut = jsOut.replace(/\\s+$/, '');\n  jsOut += `\\n${buildRegistrationSnippet(jsOut, debugId)}\\n//# debugId=${debugId}\\n`;\n  writeFileSync(p.jsPath, jsOut);\n\n  return { debugId, reused };\n}\n\n/** Inject every pair under `root`. Returns one record per pair. */\nexport function injectAll(pairs: BundlePair[]): Array<{ pair: BundlePair; result: InjectResult }> {\n  return pairs.map((pair) => ({ pair, result: injectPair(pair) }));\n}\n\n/** Read a debug ID back from a `.map` file. */\nexport function readDebugIdFromMap(mapPath: string): string | null {\n  const json = JSON.parse(readFileSync(mapPath, 'utf8')) as { debugId?: unknown };\n  return typeof json.debugId === 'string' ? json.debugId : null;\n}\n","/**\n * Source-map / bundle upload client. Build-time only.\n *\n * Wraps the AllStak `/api/v1/artifacts/upload` endpoint with multipart\n * form data and best-effort retries. Pure Node 18+ (uses the global\n * `fetch` and `FormData`), no third-party HTTP client required.\n *\n * Auth: `X-AllStak-Upload-Token` header (NOT the runtime API key —\n * uploads have a dedicated, narrower scope. Generate one in the\n * dashboard → Project Settings → Upload Tokens).\n */\n\nimport { readFileSync } from 'node:fs';\nimport { basename } from 'node:path';\n\nimport type { BundlePair } from './walk';\nimport { readDebugIdFromMap } from './inject';\n\n/** Default ingest host — overridden via `host` option or `ALLSTAK_HOST`. */\nexport const DEFAULT_HOST = 'https://api.allstak.sa';\n\n/** Options for {@link uploadAll} / {@link uploadPair}. */\nexport interface UploadOptions {\n  /** Release identifier, e.g. `myapp@1.4.2`. Required server-side. */\n  release: string;\n  /** Optional distribution tag (`web`, `ios-hermes`, `staging`, …). */\n  dist?: string;\n  /** AllStak ingest host (default `https://api.allstak.sa`). */\n  host?: string;\n  /** Project upload token (`aspk_…`). May come from `ALLSTAK_UPLOAD_TOKEN`. */\n  token: string;\n  /**\n   * Drop `sourcesContent` from the map before upload (smaller payload).\n   * Off by default — sourcesContent enables full-source rendering on the\n   * dashboard. Turn on if you don't want source code uploaded.\n   */\n  stripSources?: boolean;\n  /** Also upload the JS bundle alongside the map (off by default). */\n  uploadBundles?: boolean;\n}\n\n/** One artifact upload result. */\nexport interface UploadResult {\n  bundleName: string;\n  debugId: string;\n  /** True when both the map (and bundle, if requested) uploaded OK. */\n  ok: boolean;\n  /** Per-artifact responses, in the order we sent them. */\n  steps: Array<{\n    type: 'sourcemap' | 'bundle';\n    status: number;\n    sha8: string;\n    body?: string;\n  }>;\n}\n\ninterface OneStepResult {\n  status: number;\n  body: string;\n  ok: boolean;\n}\n\nasync function uploadOne(\n  type: 'sourcemap' | 'bundle',\n  filePath: string,\n  debugId: string,\n  opts: Required<Pick<UploadOptions, 'release' | 'host' | 'token'>> &\n    Pick<UploadOptions, 'dist' | 'stripSources'>,\n): Promise<OneStepResult> {\n  let buf = readFileSync(filePath);\n  if (type === 'sourcemap' && opts.stripSources) {\n    const json = JSON.parse(buf.toString('utf8')) as { sourcesContent?: unknown };\n    if (Array.isArray(json.sourcesContent)) delete json.sourcesContent;\n    buf = Buffer.from(JSON.stringify(json));\n  }\n\n  const form = new FormData();\n  form.append('debugId', debugId);\n  form.append('type', type);\n  form.append('release', opts.release);\n  if (opts.dist) form.append('dist', opts.dist);\n  form.append(\n    'file',\n    new Blob([buf], {\n      type: type === 'sourcemap' ? 'application/json' : 'application/javascript',\n    }),\n    basename(filePath),\n  );\n\n  const res = await fetch(opts.host.replace(/\\/$/, '') + '/api/v1/artifacts/upload', {\n    method: 'POST',\n    headers: { 'X-AllStak-Upload-Token': opts.token },\n    body: form,\n  });\n  return { status: res.status, body: await res.text(), ok: res.ok };\n}\n\nfunction sha8(buf: Buffer): string {\n  // Browser/Node fallback — keeps this file pure-JS (no node:crypto in\n  // the public surface). Caller doesn't need cryptographic strength;\n  // this is for log identification only.\n  let hash = 0;\n  for (let i = 0; i < buf.length; i++) hash = ((hash << 5) - hash + buf[i]!) | 0;\n  return (hash >>> 0).toString(16).padStart(8, '0');\n}\n\n/** Upload one bundle/map pair. The map is always uploaded; bundle is opt-in. */\nexport async function uploadPair(p: BundlePair, opts: UploadOptions): Promise<UploadResult> {\n  const debugId = readDebugIdFromMap(p.mapPath);\n  if (!debugId) {\n    return {\n      bundleName: p.bundleName,\n      debugId: '',\n      ok: false,\n      steps: [{\n        type: 'sourcemap',\n        status: 0,\n        sha8: '',\n        body: `[allstak/upload] no debugId in ${p.mapPath} — run inject first`,\n      }],\n    };\n  }\n  const merged = {\n    release: opts.release,\n    host: opts.host ?? process.env.ALLSTAK_HOST ?? DEFAULT_HOST,\n    token: opts.token,\n    dist: opts.dist,\n    stripSources: opts.stripSources,\n  };\n\n  const steps: UploadResult['steps'] = [];\n  const mapResult = await uploadOne('sourcemap', p.mapPath, debugId, merged);\n  steps.push({\n    type: 'sourcemap',\n    status: mapResult.status,\n    sha8: sha8(readFileSync(p.mapPath)),\n    body: mapResult.ok ? undefined : mapResult.body,\n  });\n\n  let allOk = mapResult.ok;\n  if (opts.uploadBundles) {\n    const bundleResult = await uploadOne('bundle', p.jsPath, debugId, merged);\n    steps.push({\n      type: 'bundle',\n      status: bundleResult.status,\n      sha8: sha8(readFileSync(p.jsPath)),\n      body: bundleResult.ok ? undefined : bundleResult.body,\n    });\n    allOk = allOk && bundleResult.ok;\n  }\n\n  return { bundleName: p.bundleName, debugId, ok: allOk, steps };\n}\n\n/** Upload every pair in parallel. */\nexport async function uploadAll(\n  pairs: BundlePair[],\n  opts: UploadOptions,\n): Promise<UploadResult[]> {\n  return Promise.all(pairs.map((p) => uploadPair(p, opts)));\n}\n","/**\n * Programmatic source-map pipeline. Build-time only.\n *\n * The high-level \"do everything\" entry point Vite/Webpack/Next plugins\n * call. Walk the build output → inject debug IDs → upload artifacts.\n *\n *   import { processBuildOutput } from '@allstak/react/sourcemaps';\n *\n *   await processBuildOutput({\n *     dir: 'dist',\n *     release: 'web@1.4.2',\n *     token: process.env.ALLSTAK_UPLOAD_TOKEN!,\n *   });\n */\n\nexport type { BundlePair } from './walk';\nexport { findPairs, walk } from './walk';\nexport type { InjectResult } from './inject';\nexport { injectPair, injectAll, readDebugIdFromMap } from './inject';\nexport type { UploadOptions, UploadResult } from './upload';\nexport { uploadPair, uploadAll, DEFAULT_HOST } from './upload';\n\nimport { resolve } from 'node:path';\nimport { findPairs } from './walk';\nimport { injectAll } from './inject';\nimport { uploadAll, type UploadOptions, type UploadResult } from './upload';\n\n/** Options for {@link processBuildOutput}. */\nexport interface ProcessOptions extends Partial<UploadOptions> {\n  /** Build output directory to scan (e.g. `dist`, `.next/static`). */\n  dir: string;\n  /**\n   * If true, only inject debug IDs and skip upload. Useful for sample\n   * apps and CI dry-runs.\n   */\n  injectOnly?: boolean;\n  /** Suppress per-pair console output. Default false (you want to see this). */\n  silent?: boolean;\n}\n\n/** What `processBuildOutput` reports back. */\nexport interface ProcessReport {\n  /** Absolute output dir scanned. */\n  dir: string;\n  /** Pairs found. */\n  pairs: number;\n  /** Per-pair injection results (debugId + reused?). */\n  injected: Array<{ bundleName: string; debugId: string; reused: boolean }>;\n  /** Per-pair upload results, omitted when no token / `injectOnly: true`. */\n  uploaded?: UploadResult[];\n}\n\nexport async function processBuildOutput(opts: ProcessOptions): Promise<ProcessReport> {\n  const dir = resolve(opts.dir);\n  const pairs = findPairs(dir);\n  const log = opts.silent ? () => undefined : (m: string) => console.log(`[allstak/sourcemaps] ${m}`);\n\n  log(`scanning ${dir} — ${pairs.length} bundle/map pair(s)`);\n  if (pairs.length === 0) {\n    return { dir, pairs: 0, injected: [] };\n  }\n\n  const injectedRaw = injectAll(pairs);\n  const injected = injectedRaw.map(({ pair, result }) => ({\n    bundleName: pair.bundleName,\n    debugId: result.debugId,\n    reused: result.reused,\n  }));\n  for (const i of injected) {\n    log(`  ${i.bundleName}  ${i.debugId}  ${i.reused ? '(reused)' : '(new)'}`);\n  }\n\n  const token = opts.token ?? process.env.ALLSTAK_UPLOAD_TOKEN;\n  const release = opts.release ?? process.env.ALLSTAK_RELEASE;\n\n  if (opts.injectOnly || !token) {\n    if (!opts.injectOnly && !token) {\n      log('skipping upload — no token (set ALLSTAK_UPLOAD_TOKEN or pass `token`)');\n    }\n    return { dir, pairs: pairs.length, injected };\n  }\n  if (!release) {\n    log('skipping upload — no release (set ALLSTAK_RELEASE or pass `release`)');\n    return { dir, pairs: pairs.length, injected };\n  }\n\n  const uploaded = await uploadAll(pairs, {\n    ...opts,\n    release,\n    token,\n  });\n  for (const u of uploaded) {\n    if (u.ok) {\n      log(`  ${u.bundleName}  uploaded debugId=${u.debugId}`);\n    } else {\n      const last = u.steps[u.steps.length - 1];\n      log(`  ${u.bundleName}  FAIL status=${last?.status ?? '?'} body=${last?.body ?? ''}`);\n    }\n  }\n  return { dir, pairs: pairs.length, injected, uploaded };\n}\n"],"mappings":"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","names":["readFileSync","basename","readFileSync","basename"]}