@allstak/react 0.3.1 → 0.3.2

package/dist/build/webpack.js

@@ -0,0 +1,256 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/build/webpack.ts
+var webpack_exports = {};
+__export(webpack_exports, {
+  AllStakWebpackPlugin: () => AllStakWebpackPlugin
+});
+module.exports = __toCommonJS(webpack_exports);
+
+// src/build/walk.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function walk(dir, out = []) {
+  for (const name of (0, import_node_fs.readdirSync)(dir)) {
+    const full = (0, import_node_path.join)(dir, name);
+    const st = (0, import_node_fs.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: (0, import_node_path.basename)(js) });
+    }
+  }
+  return pairs;
+}
+
+// src/build/inject.ts
+var import_node_fs2 = require("fs");
+var import_node_crypto = require("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 = (0, import_node_fs2.readFileSync)(p.jsPath, "utf8");
+  const mapRaw = (0, import_node_fs2.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 = (0, import_node_crypto.randomUUID)();
+  map.debugId = debugId;
+  (0, import_node_fs2.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}
+`;
+  (0, import_node_fs2.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((0, import_node_fs2.readFileSync)(mapPath, "utf8"));
+  return typeof json.debugId === "string" ? json.debugId : null;
+}
+
+// src/build/upload.ts
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var DEFAULT_HOST = "https://api.allstak.sa";
+async function uploadOne(type, filePath, debugId, opts) {
+  let buf = (0, import_node_fs3.readFileSync)(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"
+    }),
+    (0, import_node_path2.basename)(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((0, import_node_fs3.readFileSync)(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((0, import_node_fs3.readFileSync)(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
+var import_node_path3 = require("path");
+async function processBuildOutput(opts) {
+  const dir = (0, import_node_path3.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 };
+}
+
+// src/build/webpack.ts
+var AllStakWebpackPlugin = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    /** Last successful report — exposed for tests / programmatic inspection. */
+    this.lastReport = null;
+  }
+  apply(compiler) {
+    if (this.opts.disabled) return;
+    compiler.hooks.afterEmit.tapPromise("AllStakWebpackPlugin", async (compilation) => {
+      const dir = this.opts.dir ?? compilation.compiler?.outputPath ?? compiler.outputPath ?? compiler.options?.output?.path ?? process.cwd();
+      try {
+        this.lastReport = await processBuildOutput({
+          ...this.opts,
+          dir,
+          silent: this.opts.silent ?? false
+        });
+      } catch (e) {
+        console.error(`[allstak/webpack] failed: ${e.message}`);
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AllStakWebpackPlugin
+});
+//# sourceMappingURL=webpack.js.map

package/dist/build/webpack.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/build/webpack.ts","../../src/build/walk.ts","../../src/build/inject.ts","../../src/build/upload.ts","../../src/build/sourcemaps.ts"],"sourcesContent":["/**\n * Webpack plugin — same job as the Vite plugin: walk the build output\n * after emit, inject debug IDs into every JS+map pair, and (when a\n * token is present) upload to AllStak.\n *\n *   // webpack.config.js\n *   const { AllStakWebpackPlugin } = require('@allstak/react/webpack');\n *\n *   module.exports = {\n *     devtool: 'source-map',\n *     plugins: [\n *       new AllStakWebpackPlugin({\n *         release: process.env.ALLSTAK_RELEASE,\n *         token: process.env.ALLSTAK_UPLOAD_TOKEN,\n *         dist: 'web',\n *       }),\n *     ],\n *   };\n *\n * The plugin hooks `afterEmit`, the moment Webpack guarantees every\n * asset is on disk. Failures log a warning rather than failing the\n * build — a flaky CI step doesn't block shipping.\n */\n\nimport { processBuildOutput, type ProcessOptions, type ProcessReport } from './sourcemaps';\n\nexport interface AllStakWebpackPluginOptions extends Omit<ProcessOptions, 'dir'> {\n  /** Override the output directory. By default uses `compiler.outputPath`. */\n  dir?: string;\n  /** If true, plugin is a no-op. */\n  disabled?: boolean;\n}\n\ninterface MinimalCompiler {\n  hooks: { afterEmit: { tapPromise: (name: string, fn: (compilation: { compiler?: { outputPath?: string } }) => Promise<void>) => void } };\n  outputPath?: string;\n  options?: { output?: { path?: string } };\n}\n\nexport class AllStakWebpackPlugin {\n  /** Last successful report — exposed for tests / programmatic inspection. */\n  public lastReport: ProcessReport | null = null;\n\n  constructor(private readonly opts: AllStakWebpackPluginOptions = {} as AllStakWebpackPluginOptions) {}\n\n  apply(compiler: MinimalCompiler): void {\n    if (this.opts.disabled) return;\n\n    compiler.hooks.afterEmit.tapPromise('AllStakWebpackPlugin', async (compilation) => {\n      const dir =\n        this.opts.dir ??\n        compilation.compiler?.outputPath ??\n        compiler.outputPath ??\n        compiler.options?.output?.path ??\n        process.cwd();\n\n      try {\n        this.lastReport = await processBuildOutput({\n          ...this.opts,\n          dir,\n          silent: this.opts.silent ?? false,\n        });\n      } catch (e) {\n        console.error(`[allstak/webpack] failed: ${(e as Error).message}`);\n      }\n    });\n  }\n}\n","/**\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":["import_node_fs","import_node_fs","import_node_path","import_node_path"]}

package/dist/build/webpack.mjs

@@ -0,0 +1,8 @@
+import {
+  AllStakWebpackPlugin
+} from "./chunk-ZY4H5AN4.mjs";
+import "./chunk-G6VPGDP6.mjs";
+export {
+  AllStakWebpackPlugin
+};
+//# sourceMappingURL=webpack.mjs.map

package/dist/build/webpack.mjs.map

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

package/dist/index.d.mts

@@ -1,9 +1,10 @@
 import * as React from 'react';
 
 /**
- * Minimal HTTP transport for React Native. Uses the global `fetch` (always
- * present in RN >= 0.60) with a 3s timeout. Failed sends fall into a small
- * in-memory ring buffer that we retry on the next successful flush.
+ * Fail-open HTTP transport for browser/React. Telemetry sends are best-effort:
+ * they use a short timeout, never reject into the host app, and fall into a
+ * bounded in-memory ring buffer with circuit-breaker backoff when AllStak is
+ * unavailable.
  *
  * No window, no AbortController fallback shims — RN exposes both natively.
  */
@@ -12,10 +13,17 @@ declare class HttpTransport {
     private apiKey;
     private buffer;
     private flushing;
+    private consecutiveFailures;
+    private circuitOpenUntil;
     constructor(baseUrl: string, apiKey: string);
     send(path: string, payload: unknown): Promise<void>;
+    private enqueueOrDispatch;
+    private dispatch;
     private doFetch;
+    private push;
+    private scheduleFlush;
     private flushBuffer;
+    private recordFailure;
     getBufferSize(): number;
     /**
      * Wait for the in-flight retry-buffer to drain. Resolves `true` if the
@@ -303,9 +311,44 @@ interface HttpTrackingOptions {
     maxBodyBytes?: number;
 }
 
+/**
+ * Idempotent instrumentation of `globalThis.fetch` and `console.warn/error`
+ * to feed breadcrumbs into the AllStak client. Safe to call once at init.
+ *
+ * - `instrumentFetch`: wraps fetch and records a breadcrumb per request
+ *   (success and failure). Skips requests targeting the SDK's own ingest
+ *   host so the wrap never recurses. Preserves the original return type
+ *   and rethrows fetch errors after the breadcrumb is recorded.
+ * - `instrumentConsole`: wraps `console.warn` and `console.error` to
+ *   record `log`-type breadcrumbs at the corresponding level.
+ *
+ * Both patches use a flag on the wrapper function so a second call is a
+ * no-op — important because hot-module-reload in dev would otherwise
+ * stack patches and double-fire breadcrumbs.
+ */
+type AddBreadcrumbFn$1 = (type: string, msg: string, level?: string, data?: Record<string, unknown>) => void;
+declare function instrumentFetch(addBreadcrumb: AddBreadcrumbFn$1, ownBaseUrl?: string): void;
+/**
+ * Per-console-method capture flags. Defaults: warn + error captured,
+ * log + info NOT captured (typical React apps emit thousands of debug
+ * lines per session — flooding the dashboard with them creates pure
+ * noise, so they're opt-in).
+ *
+ *   <AllStakProvider captureConsole={{ log: true, info: true }} />
+ */
+interface ConsoleCaptureOptions {
+    log?: boolean;
+    info?: boolean;
+    warn?: boolean;
+    error?: boolean;
+}
+declare function instrumentConsole(addBreadcrumb: AddBreadcrumbFn$1, options?: ConsoleCaptureOptions): void;
+/** @internal — for tests. Resets the wrap-once flag. */
+declare function __resetConsoleInstrumentationFlagForTest(): void;
+
 declare const INGEST_HOST = "https://api.allstak.sa";
 declare const SDK_NAME = "allstak-react";
-declare const SDK_VERSION = "0.3.0";
+declare const SDK_VERSION = "0.3.1";
 
 interface AllStakConfig {
     /** Project API key (`ask_live_…`). Required. */
@@ -342,8 +385,22 @@ interface AllStakConfig {
     autoCaptureBrowserErrors?: boolean;
     /** Wrap `globalThis.fetch` to record HTTP breadcrumbs. Default: true */
     autoBreadcrumbsFetch?: boolean;
-    /** Wrap `console.warn` and `console.error` to record log breadcrumbs. Default: true */
+    /** Wrap `console.*` methods to record log breadcrumbs. Default: true.
+     * Per-method capture is controlled by `captureConsole` (warn + error
+     * default on, log + info default off). */
     autoBreadcrumbsConsole?: boolean;
+    /**
+     * Per-console-method capture flags. Defaults: warn + error captured,
+     * log + info NOT captured (to avoid breadcrumb spam from typical app
+     * logging). Set `{ log: true, info: true }` to opt-in.
+     */
+    captureConsole?: ConsoleCaptureOptions;
+    /**
+     * Auto-capture Web Vitals (CLS, LCP, INP, FCP, TTFB) via the browser's
+     * PerformanceObserver. Default: true. Each metric ships as a
+     * `web_vitals` log on the next backend flush.
+     */
+    autoWebVitals?: boolean;
     /** Wrap `history.pushState`/`replaceState` and listen to `popstate` for SPA navigation breadcrumbs. Default: true */
     autoBreadcrumbsNavigation?: boolean;
     /**
@@ -440,6 +497,7 @@ declare class AllStakClient {
     private _instrumentAxios;
     private onErrorHandler;
     private onRejectionHandler;
+    private webVitals;
     constructor(config: AllStakConfig);
     /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
     instrumentAxios<T = any>(axios: T): T;
@@ -576,6 +634,80 @@ declare const AllStak: {
     /** @internal */ _getInstance(): AllStakClient | null;
 };
 
+interface AllStakProviderProps {
+    children: React.ReactNode;
+    apiKey: string;
+    environment?: string;
+    release?: string;
+    host?: string;
+    user?: {
+        id?: string;
+        email?: string;
+    };
+    tags?: Record<string, string>;
+    debug?: boolean;
+    enableHttpTracking?: boolean;
+    httpTracking?: AllStakConfig['httpTracking'];
+    /**
+     * Per-console-method capture flags. Defaults: warn + error captured,
+     * log + info NOT captured (to avoid breadcrumb spam from typical app
+     * logging). Set `{ log: true, info: true }` to opt-in.
+     */
+    captureConsole?: AllStakConfig['captureConsole'];
+    sampleRate?: number;
+    beforeSend?: AllStakConfig['beforeSend'];
+    replay?: AllStakConfig['replay'];
+    tracesSampleRate?: number;
+    service?: string;
+    dist?: string;
+    /** Default true. Capture window error + unhandledrejection. */
+    autoCaptureBrowserErrors?: boolean;
+    /** Default true. Wrap fetch for breadcrumbs. */
+    autoBreadcrumbsFetch?: boolean;
+    /** Default true. Wrap console for breadcrumbs (per-method via captureConsole). */
+    autoBreadcrumbsConsole?: boolean;
+    /** Default true. Patch history.pushState/replaceState + popstate listener. */
+    autoBreadcrumbsNavigation?: boolean;
+    /** Default true. Collect Web Vitals via PerformanceObserver. */
+    autoWebVitals?: boolean;
+    /**
+     * Tear down the SDK when the provider unmounts. Default `false`.
+     *
+     * Most apps mount `AllStakProvider` once at the root and never unmount
+     * it. Setting this to `true` risks disabling telemetry if the provider
+     * re-mounts (Fast Refresh in dev, route key changes, React 18 Strict
+     * Mode double-mount, etc.) — there is a brief window between unmount
+     * and remount where captures throw.
+     *
+     * Leave at the default unless you genuinely need to dispose the SDK.
+     */
+    destroyOnUnmount?: boolean;
+    fallback?: React.ReactNode | ((props: {
+        error: Error;
+        resetError: () => void;
+    }) => React.ReactNode);
+    onError?: (error: Error, componentStack?: string) => void;
+}
+declare function AllStakProvider({ children, apiKey, environment, release, host, user, tags, debug, enableHttpTracking, httpTracking, captureConsole, sampleRate, beforeSend, replay, tracesSampleRate, service, dist, autoCaptureBrowserErrors, autoBreadcrumbsFetch, autoBreadcrumbsConsole, autoBreadcrumbsNavigation, autoWebVitals, destroyOnUnmount, fallback, onError, }: AllStakProviderProps): React.ReactElement;
+/**
+ * Convenience hook — exposes the most common capture/context APIs with
+ * a stable identity so components don't have to import the namespace.
+ */
+declare function useAllStak(): {
+    captureException: (error: Error, ctx?: Record<string, unknown>) => void;
+    captureMessage: (msg: string, level?: "fatal" | "error" | "warning" | "info") => void;
+    setUser: (user: {
+        id?: string;
+        email?: string;
+    }) => void;
+    setTag: (key: string, value: string) => void;
+    setContext: (name: string, ctx: Record<string, unknown> | null) => void;
+    addBreadcrumb: (type: string, message: string, level?: string, data?: Record<string, unknown>) => void;
+    flush: (timeoutMs?: number) => Promise<boolean>;
+};
+/** @internal — for tests. Resets the module-level remount-guard. */
+declare function __resetProviderInstanceForTest(): void;
+
 /**
  * Browser navigation breadcrumbs — minimal fallback that doesn't depend on
  * any specific router library. Wraps `history.pushState`/`replaceState` and
@@ -588,41 +720,77 @@ declare const AllStak: {
  * For framework-specific instrumentation (React Router's `useNavigate`,
  * Next's `router.events`), bind manually with `AllStak.addBreadcrumb`.
  */
-type AddBreadcrumbFn$1 = (type: string, msg: string, level?: string, data?: Record<string, unknown>) => void;
-declare function instrumentBrowserNavigation(addBreadcrumb: AddBreadcrumbFn$1): void;
+type AddBreadcrumbFn = (type: string, msg: string, level?: string, data?: Record<string, unknown>) => void;
+declare function instrumentBrowserNavigation(addBreadcrumb: AddBreadcrumbFn): void;
 declare function instrumentReactRouter(location: {
     pathname: string;
     search?: string;
-}, addBreadcrumb?: AddBreadcrumbFn$1): void;
-declare function instrumentNextRouter(url: string, addBreadcrumb?: AddBreadcrumbFn$1): void;
+}, addBreadcrumb?: AddBreadcrumbFn): void;
+declare function instrumentNextRouter(url: string, addBreadcrumb?: AddBreadcrumbFn): void;
 
 /**
- * Idempotent instrumentation of `globalThis.fetch` and `console.warn/error`
- * to feed breadcrumbs into the AllStak client. Safe to call once at init.
+ * Lightweight Web Vitals collection via the browser's PerformanceObserver.
  *
- * - `instrumentFetch`: wraps fetch and records a breadcrumb per request
- *   (success and failure). Skips requests targeting the SDK's own ingest
- *   host so the wrap never recurses. Preserves the original return type
- *   and rethrows fetch errors after the breadcrumb is recorded.
- * - `instrumentConsole`: wraps `console.warn` and `console.error` to
- *   record `log`-type breadcrumbs at the corresponding level.
+ * Captures CLS, LCP, INP, FCP, TTFB without pulling in the `web-vitals`
+ * package as a runtime dependency. Each metric is shipped as a single
+ * `web_vital` log on the SDK's `/ingest/v1/logs` channel — so the
+ * dashboard can chart them alongside other logs.
  *
- * Both patches use a flag on the wrapper function so a second call is a
- * no-op — important because hot-module-reload in dev would otherwise
- * stack patches and double-fire breadcrumbs.
+ * Privacy: only numeric values + the metric name are sent. No URLs,
+ * referrers, or user-identifiable data.
+ *
+ * Browser compatibility: PerformanceObserver is available in every
+ * evergreen browser (Chrome 51+, Safari 11+, Firefox 57+, Edge 79+).
+ * Older browsers silently no-op via the `typeof PerformanceObserver`
+ * guard.
+ *
+ *   - **CLS** (Cumulative Layout Shift) — layout-shift entries with
+ *     `hadRecentInput=false`, summed for the session
+ *   - **LCP** (Largest Contentful Paint) — biggest paint entry's startTime
+ *   - **INP** (Interaction to Next Paint) — longest event-timing duration
+ *   - **FCP** (First Contentful Paint) — first paint named `first-contentful-paint`
+ *   - **TTFB** (Time to First Byte) — `responseStart - requestStart` from the
+ *     navigation timing entry
  */
-type AddBreadcrumbFn = (type: string, msg: string, level?: string, data?: Record<string, unknown>) => void;
-declare function instrumentFetch(addBreadcrumb: AddBreadcrumbFn, ownBaseUrl?: string): void;
-declare function instrumentConsole(addBreadcrumb: AddBreadcrumbFn): void;
+type VitalsReporter = (metric: {
+    name: string;
+    value: number;
+    id?: string;
+}) => void;
+interface WebVitalsHandle {
+    /** Disconnects all observers. Idempotent. */
+    destroy(): void;
+}
+/**
+ * Start collecting Web Vitals. Returns a handle whose `destroy()` cleans
+ * up all PerformanceObservers. Safe no-op on non-browser runtimes.
+ */
+declare function startWebVitals(report: VitalsReporter): WebVitalsHandle;
+/** @internal — reset the started flag so tests can re-init. */
+declare function __resetWebVitalsFlagForTest(): void;
 
 /**
  * @allstak/react — standalone React SDK.
  *
  * Self-contained: no @allstak/js or @allstak-io/* dependencies. Ships its own
  * AllStak client (init/capture/breadcrumbs/transport) plus React-specific
- * helpers (ErrorBoundary, useAllStak hook, withAllStakProfiler HOC).
+ * helpers (Provider, ErrorBoundary, useAllStak hook, withAllStakProfiler HOC).
+ *
+ * Recommended usage (one-liner):
+ *
+ *   import { AllStakProvider } from '@allstak/react';
+ *
+ *   export function App() {
+ *     return (
+ *       <AllStakProvider apiKey="ask_live_..." environment="production" debug>
+ *         <AppRoot />
+ *       </AllStakProvider>
+ *     );
+ *   }
  *
- * Usage:
+ * Advanced / manual usage:
+ *
+ *   import { AllStak } from '@allstak/react';
  *   AllStak.init({ apiKey, environment, release });
  *   <AllStakErrorBoundary>...</AllStakErrorBoundary>
  *   const { captureException } = useAllStak();
@@ -650,23 +818,9 @@ declare class AllStakErrorBoundary extends React.Component<AllStakErrorBoundaryP
     render(): React.ReactNode;
 }
 /**
- * Convenience hook — exposes the most common capture/context APIs with a
- * stable identity so components don't have to import the namespace.
- */
-declare function useAllStak(): {
-    captureException: (error: Error, ctx?: Record<string, unknown>) => void;
-    captureMessage: (msg: string, level?: "fatal" | "error" | "warning" | "info") => void;
-    setUser: (user: {
-        id?: string;
-        email?: string;
-    }) => void;
-    setTag: (key: string, value: string) => void;
-    addBreadcrumb: (type: string, message: string, level?: string, data?: Record<string, unknown>) => void;
-};
-/**
- * HOC: drops a navigation breadcrumb when a component mounts. Useful for
- * marking screen boundaries without a router.
+ * HOC: drops a navigation breadcrumb when a component mounts. Useful
+ * for marking screen boundaries without a router.
  */
 declare function withAllStakProfiler<P extends object>(Component: React.ComponentType<P>, name?: string): React.FC<P>;
 
-export { AllStak, AllStakClient, type AllStakConfig, AllStakErrorBoundary, type AllStakErrorBoundaryProps, type Breadcrumb, type HttpRequestEvent, HttpRequestModule, type HttpTrackingOptions, INGEST_HOST, type ReplayOptions, ReplayRecorder, SDK_NAME, SDK_VERSION, Scope, instrumentBrowserNavigation, instrumentConsole, instrumentFetch, instrumentNextRouter, instrumentReactRouter, useAllStak, withAllStakProfiler };
+export { AllStak, AllStakClient, type AllStakConfig, AllStakErrorBoundary, type AllStakErrorBoundaryProps, AllStakProvider, type AllStakProviderProps, type Breadcrumb, type ConsoleCaptureOptions, type HttpRequestEvent, HttpRequestModule, type HttpTrackingOptions, INGEST_HOST, type ReplayOptions, ReplayRecorder, SDK_NAME, SDK_VERSION, Scope, type WebVitalsHandle, __resetConsoleInstrumentationFlagForTest, __resetProviderInstanceForTest, __resetWebVitalsFlagForTest, instrumentBrowserNavigation, instrumentConsole, instrumentFetch, instrumentNextRouter, instrumentReactRouter, startWebVitals, useAllStak, withAllStakProfiler };