@lightworkai.official/debug-capture 0.19.8 → 0.19.10

package/dist/replayPack.d.ts

@@ -1,3 +1,4 @@
+import { type PictureEncoder } from "./replayPictures";
 import type { ReplayCapture, ReplayEvent, ReplaySummary } from "./types";
 /** The name the desk looks for. Changing it here changes it nowhere else. */
 export declare const REPLAY_FILENAME = "session-replay.json.gz";
@@ -6,6 +7,12 @@ export interface PackedReplay {
     filename: string;
     summary: ReplaySummary;
 }
+export interface PackOptions {
+    /** JPEG quality for a canvas picture the browser could only make as PNG. Default 0.5. */
+    quality?: number;
+    /** How such a picture is made lighter. Default the browser's own encoder; null skips the step. */
+    lighten?: PictureEncoder | null;
+}
 /** Is there something to attach, before the work of packing it. */
 export declare function hasReplayEvents(replay: ReplayCapture | null | undefined): replay is ReplayCapture;
 /**
@@ -14,9 +21,55 @@ export declare function hasReplayEvents(replay: ReplayCapture | null | undefined
  * The cap is applied to what is SENT — compressed bytes when compression is
  * available — because that is the number the server's per-file limit is
  * measured against.
+ *
+ * Over the cap, a report still carries a recording. Each step below is taken
+ * only when the one before it did not fit, and each gives up less than the
+ * next:
+ *
+ *   1. Safari's PNG canvas pictures saved again as JPEG (replayPictures) —
+ *      nothing visible is lost.
+ *   2. Canvas pictures kept from the latest moment that fits, the earlier
+ *      ones left out: the document as it last looked, over the whole
+ *      recording. A canvas whose picture went plays blank until it is next
+ *      drawn.
+ *   3. Every canvas picture left out: the canvases stay, blank; every
+ *      click, page and field is still there.
+ *   4. Large pictures embedded in the page itself (a `data:` image, a font
+ *      inlined in a stylesheet) swapped for an empty one.
+ *   5. The oldest part left out: the recording is kept in stretches that
+ *      each begin with a full picture of the page (capture/replay — a
+ *      checkout every half of the configured length), so the latest
+ *      stretches play on their own. As many as fit, newest first.
+ *   6. The latest stretch from its start, as far as fits — it then stops
+ *      before the report, and the ticket says by how much.
+ *   7. Long text and styles shortened, when not even the page's own picture
+ *      fits.
+ *
+ * Only a page whose single picture is over the cap after all of that goes
+ * without — millions of elements. CIB-5880 (2026-11-02) went without at
+ * step 3: the strip missed every canvas added after the snapshot, and
+ * Safari's pictures are PNG.
  */
-export declare function packReplay(replay: ReplayCapture | null | undefined, maxBytes: number): Promise<PackedReplay | {
+export declare function packReplay(replay: ReplayCapture | null | undefined, maxBytes: number, options?: PackOptions): Promise<PackedReplay | {
     summary: ReplaySummary;
 }>;
-/** The same replay with every canvas picture removed — the canvases stay, blank. */
-export declare function stripCanvas(events: readonly ReplayEvent[]): ReplayEvent[];
+/**
+ * Every canvas picture removed, in place — the canvases stay, blank. The
+ * snapshot's and those on a canvas added later alike: missing the second
+ * kind is how CIB-5749 went out marked `canvasDropped` with 1.05 MB of
+ * pictures on fourteen canvases still in it. Canvas frames are dropped by
+ * the caller (`isCanvasFrame`). Whether there was anything to remove.
+ */
+export declare function stripCanvas(events: readonly ReplayEvent[]): boolean;
+/**
+ * Large pictures the page itself holds — an `<img src="data:…">`, a font or
+ * background inlined in a stylesheet — swapped for an empty one, in place,
+ * wherever the events carry them: attributes, styles, style rules.
+ */
+export declare function dropEmbedded(events: readonly ReplayEvent[]): boolean;
+/**
+ * The recording in its stretches, each from a Meta and full snapshot to the
+ * next — the units it can be shortened by and still play. Anything before
+ * the first Meta rides with the first stretch.
+ */
+export declare function splitWindows(events: readonly ReplayEvent[]): ReplayEvent[][];

package/dist/replayPictures.d.ts

@@ -0,0 +1,33 @@
+import type { ReplayEvent } from "./types";
+export interface Picture {
+    base64: string;
+    type: string;
+}
+/** A picture as JPEG, or null to keep it as it is. */
+export type PictureEncoder = (picture: Picture) => Promise<Picture | null>;
+/** One place a picture is kept, and how to put a new one there. */
+interface Slot {
+    picture: Picture;
+    put: (next: Picture) => void;
+}
+/** Every canvas picture in the events, wherever the recorder put it. */
+export declare function pictureSlots(events: readonly ReplayEvent[]): Slot[];
+/** Every picture's base64, as often as it occurs — gzip's 32 KB window never sees a picture's earlier copy. */
+export declare function pictureStrings(events: readonly ReplayEvent[]): string[];
+/** Whether there is anything for `lightenPictures` to do — before the work of decoding. */
+export declare function hasHeavyPngs(events: readonly ReplayEvent[]): boolean;
+/**
+ * Each large PNG replaced by what `encode` makes of it, when that is smaller.
+ * The same picture is encoded once however often it recurs — a page's
+ * picture is in every snapshot the recording holds. Returns how many changed.
+ * A picture the encoder fails on stays as it was: this never throws.
+ */
+export declare function lightenPictures(events: ReplayEvent[], encode: PictureEncoder): Promise<number>;
+/**
+ * The browser's own encoder: the PNG decoded, checked opaque pixel by pixel,
+ * and saved as JPEG at `quality`. Null where the browser lacks what it takes
+ * (no `createImageBitmap`), for a picture anything shows through, and for a
+ * browser that hands back something other than a JPEG.
+ */
+export declare function browserJpeg(quality: number): PictureEncoder | null;
+export {};

package/dist/types.d.ts

@@ -189,7 +189,7 @@ export interface ReplayCapture {
  * attachment loads — or say why there is none.
  */
 export interface ReplaySummary {
-    /** Whole seconds covered, when one was attached. */
+    /** Whole seconds covered by what was attached (or, with `omitted`, by what was recorded). */
     seconds?: number;
     events?: number;
     startedAt?: string;
@@ -197,8 +197,16 @@ export interface ReplaySummary {
     /** Size of the attachment as sent, and whether it is gzip. */
     bytes?: number;
     compressed?: boolean;
-    /** The canvas frames were left out to fit under the size cap. */
+    /** Canvas pictures left out: the canvases play blank. */
     canvasDropped?: boolean;
+    /** Large pictures embedded in the page (a `data:` image, an inlined font) left out. */
+    picturesDropped?: boolean;
+    /** Long text and styles shortened — only when not even one picture of the page fitted otherwise. */
+    simplified?: boolean;
+    /** Only part of the recording went: how long the whole was. `seconds` is what was sent. */
+    recordedSeconds?: number;
+    /** The part sent stops this many seconds before the report was made. */
+    endsEarlySeconds?: number;
     /** Present when the host records but this report carries no replay. */
     omitted?: "too-large" | "empty";
 }

package/dist/ui/chatBubble.d.ts

@@ -1,4 +1,9 @@
 import { type PlaceRule } from "./bubblePlace";
+/**
+ * The desk's size for it, px (0.19.10; the owner, 11-02: "make it smaller or bigger as a config") — the desk offers
+ * 44 to 72; anything else it might say is brought within reach of a finger and of the corner. Pure.
+ */
+export declare function bubbleSize(v: unknown): number;
 /** The panel's address: the support host's page, told the realm, signing in by hand-off (no token in the address). */
 export declare function supportFrameUrl(host: string, realmKey: string): string;
 /** Where the panel's เปิดในระบบแจ้งปัญหา may land: the person's chat or their เรื่อง — anything else, their chat. Pure. */
@@ -9,9 +14,9 @@ export declare function supportFaceUrl(host: string): string;
  * How far the call's card and frame rise from their own 16px so they clear the bubble — its offset, its size and the
  * gap above it (0.19.1: 0.19.0 assumed the bubble at the corner, and a raised one sat under a ringing call). Pure.
  */
-export declare function chatLift(bubbleY: number): number;
+export declare function chatLift(bubbleY: number, s?: number): number;
 /** The panel above the bubble, never past the top of the window — its height for the bubble's offset (0.19.1). Pure. */
-export declare function panelHeight(bubbleY: number): string;
+export declare function panelHeight(bubbleY: number, s?: number): string;
 export interface BubbleSpot {
     side: "right" | "left";
     /** In from that side, px. */
@@ -23,16 +28,16 @@ export interface BubbleSpot {
 export declare function settleBubble(px: number, py: number, view: {
     w: number;
     h: number;
-}, inset: number): BubbleSpot;
+}, inset: number, s?: number): BubbleSpot;
 /** A height that keeps the whole bubble on screen. Pure. */
-export declare function clampBubbleY(y: number, viewH: number): number;
+export declare function clampBubbleY(y: number, viewH: number, s?: number): number;
 /** How far the call's card rises to clear the bubble: only a bubble on its side, low enough to meet it. Pure. */
-export declare function liftFor(spot: BubbleSpot): number;
+export declare function liftFor(spot: BubbleSpot, s?: number): number;
 /**
  * The panel by the bubble, where it was not dragged: above it when the room above is enough (or more than below),
  * else below it — its own height, never past the window. Pure.
  */
-export declare function anchorPanel(spot: BubbleSpot, viewH: number): {
+export declare function anchorPanel(spot: BubbleSpot, viewH: number, s?: number): {
     bottom?: number;
     top?: number;
     height: number;
@@ -75,6 +80,8 @@ export interface DeskLook {
     avoid?: boolean;
     /** A page's own place (0.19.6): hidden there, or started in a corner at a height — the desk's rules. */
     places?: PlaceRule[];
+    /** ขนาดปุ่ม, px (0.19.10) — 56 when the desk does not say. */
+    size?: number;
 }
 /** The face's address for a desk's look: its own path on the support host, the shipped one, or none (the glyph). Pure. */
 export declare function lookFaceUrl(host: string, look: DeskLook | null): string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightworkai.official/debug-capture",
-  "version": "0.19.8",
+  "version": "0.19.10",
   "description": "Report-a-problem widget: rolling network/console/action capture, optional rrweb session replay, annotated screenshot, and submission to a Lightwork Support host",
   "type": "module",
   "module": "./dist/index.mjs",