@merittdev/horus-lens 0.4.0 → 0.5.1

package/dist/browser.d.cts

@@ -1,4 +1,4 @@
-import { L as LensConfig, a as LensClient } from './index.d-BYG_Mjs-.cjs';
+import { L as LensConfig, a as LensClient } from './index.d-DeJ1mfh0.cjs';
 import { z } from 'zod';
 import './index.d-DTx4C384.cjs';
 

package/dist/browser.d.ts

@@ -1,4 +1,4 @@
-import { L as LensConfig, a as LensClient } from './index.d-Dyzc1E9T.js';
+import { L as LensConfig, a as LensClient } from './index.d-BYuZWEkh.js';
 import { z } from 'zod';
 import './index.d-DTx4C384.js';
 

package/dist/browser.js

@@ -7,8 +7,8 @@ import {
   isGateActive,
   loaderSnippet,
   processQueue
-} from "./chunk-GQREYSHC.js";
-import "./chunk-B7QI3T3E.js";
+} from "./chunk-MN44USB4.js";
+import "./chunk-GVULQ2IF.js";
 export {
   DEFAULT_CDN_URL,
   LOADER_SNIPPET,

package/dist/{chunk-B7QI3T3E.js → chunk-GVULQ2IF.js}

@@ -29063,7 +29063,7 @@ async function domToBlob(node2, options) {
 
 // ../core/dist/index.js
 var SDK_NAME = "@merittdev/horus-lens";
-var SDK_VERSION = true ? "0.4.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "0.5.1" : "0.0.0-dev";
 var DEFAULT_ENDPOINT = "https://api.horus.sh";
 var DEFAULT_REPLAY_WINDOW_MS = 15e3;
 var DEFAULT_MAX_CONSOLE_ENTRIES = 200;
@@ -29124,11 +29124,15 @@ function startAutoCapture(client, options = {}) {
     const last = lastSeen.get(signature);
     if (last !== void 0 && now - last < AUTO_CAPTURE_COOLDOWN_MS) return;
     if (sessionCount >= AUTO_CAPTURE_SESSION_CAP) return;
+    const previousSeen = lastSeen.get(signature);
     lastSeen.set(signature, now);
     sessionCount += 1;
     submitting = true;
     options.onCapture?.(signature);
     void Promise.resolve().then(() => client.submitReport({ trigger: "error", include: { screenshot: false } })).catch(() => {
+      if (previousSeen === void 0) lastSeen.delete(signature);
+      else lastSeen.set(signature, previousSeen);
+      sessionCount -= 1;
     }).finally(() => {
       submitting = false;
     });
@@ -29183,6 +29187,14 @@ var RingBuffer = class {
     return this.items.length;
   }
 };
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HttpError";
+  }
+  status;
+};
 var Transport = class {
   constructor(config2) {
     this.config = config2;
@@ -29190,18 +29202,23 @@ var Transport = class {
   config;
   async initiate(assets) {
     const body = { accessId: this.config.accessId, assets };
-    return this.postJson(`${this.config.endpoint}/v1/reports/initiate`, body);
+    return this.postJson(
+      `${this.config.endpoint}/v1/reports/initiate`,
+      body,
+      { retries: 0 }
+    );
   }
   /** Record a late-uploaded asset (background screenshot) on a finalized report. */
   async attachAsset(reportId, asset) {
     const body = { accessId: this.config.accessId, ...asset };
     await this.postJson(`${this.config.endpoint}/v1/reports/${encodeURIComponent(reportId)}/assets`, body);
   }
-  async uploadAsset(upload, blob2) {
+  async uploadAsset(upload, blob2, signal) {
     const response = await fetch(upload.url, {
       method: upload.method,
       headers: upload.headers,
-      body: blob2
+      body: blob2,
+      signal
     });
     if (!response.ok) {
       throw new Error(`Asset upload failed (${upload.kind}): ${response.status}`);
@@ -29209,12 +29226,20 @@ var Transport = class {
   }
   async finalize(reportId, metadata, uploadedAssets) {
     const body = { accessId: this.config.accessId, metadata, uploadedAssets };
-    return this.postJson(
-      `${this.config.endpoint}/v1/reports/${reportId}/finalize`,
-      body
-    );
+    try {
+      return await this.postJson(
+        `${this.config.endpoint}/v1/reports/${reportId}/finalize`,
+        body
+      );
+    } catch (err) {
+      if (err instanceof HttpError && err.status === 409) {
+        return { reportId, status: "submitted" };
+      }
+      throw err;
+    }
   }
-  async postJson(url2, body, retries = 1) {
+  async postJson(url2, body, opts = {}) {
+    const retries = opts.retries ?? 1;
     let lastError;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
@@ -29225,7 +29250,10 @@ var Transport = class {
         });
         if (!response.ok) {
           const text = await response.text().catch(() => "");
-          throw new Error(`Request to ${url2} failed: ${response.status} ${text}`.trim());
+          throw new HttpError(
+            response.status,
+            `Request to ${url2} failed: ${response.status} ${text}`.trim()
+          );
         }
         return await response.json();
       } catch (err) {
@@ -29616,8 +29644,11 @@ function computeCropRect(crop, scale, rasterWidth, rasterHeight) {
 async function captureScreenshot(excludeHost, crop, composite) {
   if (typeof document === "undefined" || typeof window === "undefined") return null;
   try {
-    const viewportPixels = window.innerWidth * window.innerHeight || 1;
-    const pixelCap = Math.sqrt(SCREENSHOT_MAX_PIXELS / viewportPixels);
+    const viewportOnly = !composite && !crop;
+    const captureW = composite ? composite.docWidth : window.innerWidth;
+    const captureH = composite ? composite.docHeight : window.innerHeight;
+    const capturePixels = captureW * captureH || 1;
+    const pixelCap = Math.sqrt(SCREENSHOT_MAX_PIXELS / capturePixels);
     const scale = Math.max(1, Math.min(window.devicePixelRatio || 1, SCREENSHOT_MAX_SCALE, pixelCap));
     const capture = domToBlob(document.documentElement, {
       scale,
@@ -29626,12 +29657,19 @@ async function captureScreenshot(excludeHost, crop, composite) {
       // JPEG has no alpha — transparent page regions (and any capture box
       // extending past short content) would otherwise encode as BLACK.
       backgroundColor: "#ffffff",
-      // When compositing annotations, force the capture box to the editor's
-      // document measurement (scrollHeight-based). modern-screenshot otherwise
-      // sizes from documentElement's bounding box, which on pages SHORTER than
-      // the viewport is the content height only — marks drawn in the lower
-      // viewport band would fall off the raster and the crop would clamp short.
+      // Composite (annotations): force the capture box to the editor's document
+      // measurement so marks in the lower viewport band aren't clipped.
       ...composite ? { width: composite.docWidth, height: composite.docHeight } : {},
+      // Plain report: clip the render to the viewport and shift the scrolled
+      // content into it, so only the visible region is rasterized/fetched.
+      ...viewportOnly ? {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        style: {
+          transform: `translate(${-window.scrollX}px, ${-window.scrollY}px)`,
+          transformOrigin: "top left"
+        }
+      } : {},
       // Exclude the overlay from the capture CLONE — never hide the live node.
       filter: (node2) => node2 !== excludeHost,
       // Per-resource fetch budget: a single slow cross-origin image must not
@@ -30101,12 +30139,22 @@ var LensClient = class {
       input2.screenshotCrop,
       input2.annotationComposite
     ) : Promise.resolve(null);
+    const consumingManualRecording = wantReplay && (this.replay?.hasManualRecording() ?? false) && !(this.replay?.isManualRecording() ?? false);
     const replayEvents = wantReplay ? this.replay?.snapshot() ?? [] : [];
     const errorEntries = this.errorBuffer.drain();
-    const consoleTail = this.consoleBuffer.tail(CONSOLE_TAIL_SIZE);
-    const networkTail = this.networkBuffer.tail(NETWORK_TAIL_SIZE);
     const consoleEntries = this.consoleBuffer.drain();
     const networkEntries = this.networkBuffer.drain();
+    this.errorBuffer.clear();
+    this.consoleBuffer.clear();
+    this.networkBuffer.clear();
+    const consoleTail = consoleEntries.slice(-CONSOLE_TAIL_SIZE);
+    const isNetFailure = (e) => e.ok !== true || Boolean(e.error);
+    const recentFailures = networkEntries.filter(isNetFailure).slice(-NETWORK_TAIL_SIZE);
+    const keep = /* @__PURE__ */ new Set([
+      ...recentFailures,
+      ...networkEntries.slice(-NETWORK_TAIL_SIZE)
+    ]);
+    const networkTail = networkEntries.filter((e) => keep.has(e)).slice(-NETWORK_TAIL_SIZE);
     let metadata = {
       annotations: input2.annotations ?? [],
       env: collectEnv(),
@@ -30160,13 +30208,14 @@ var LensClient = class {
       }
       if (!asset.blob) continue;
       try {
-        await this.transport.uploadAsset(upload, asset.blob);
+        await this.uploadAssetWithTimeout(upload, asset.blob);
         uploadedAssets.push({ kind: upload.kind, key: upload.key, byteSize: asset.blob.size });
       } catch (err) {
         this.warn(`asset upload failed (${upload.kind})`, err);
       }
     }
     const finalized = await this.transport.finalize(initiated.reportId, metadata, uploadedAssets);
+    if (consumingManualRecording) this.replay?.discardManualRecording();
     if (screenshotUpload) {
       const upload = screenshotUpload;
       void screenshotPromise.then(async (blob2) => {
@@ -30184,6 +30233,21 @@ var LensClient = class {
     }
     return { reportId: finalized.reportId };
   }
+  /**
+   * Upload a foreground asset with a bounded timeout. Without this a stuck S3
+   * PUT (dropped connection, half-open socket) would hang `submitReport`
+   * forever; the timeout aborts the individual PUT so it fails as one asset
+   * (caught by the caller) instead of wedging the whole submit.
+   */
+  async uploadAssetWithTimeout(upload, blob2) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), SCREENSHOT_TIMEOUT_MS);
+    try {
+      await this.transport.uploadAsset(upload, blob2, controller.signal);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   warn(message, err) {
     if (!this.debug) return;
     if (err !== void 0) console.warn(`[lens] ${message}`, err);
@@ -30241,4 +30305,4 @@ rrweb/dist/rrweb.js:
   PERFORMANCE OF THIS SOFTWARE.
   ***************************************************************************** *)
 */
-//# sourceMappingURL=chunk-B7QI3T3E.js.map
+//# sourceMappingURL=chunk-GVULQ2IF.js.map