@sailfish-ai/recorder 1.12.5 → 1.12.6

package/dist/types/canvas/patch2d.d.ts

@@ -0,0 +1,339 @@
+/**
+ * Global 2D-context instrumentation: prototype patches that feed per-context
+ * recorders. Port of the validated bench core
+ * (test-applications/canvas-recorder-bench/src/capture/patch2d.ts).
+ *
+ * Captures: every CanvasRenderingContext2D method call + property set,
+ * gradient/pattern creation (interned objects), image sources (asset CAS),
+ * ImageData, and a shadow state stack (props + transform per save()) that
+ * makes keyframe seeking possible.
+ *
+ * SDK adaptations (everything else is a faithful port):
+ *  - NO window/document/navigator access at module top level (SSR rule);
+ *    all installation happens inside exported install functions.
+ *  - `encodeImage` returns `{size, bytes?}` so encoded webp payloads can be
+ *    shipped as SFCV asset frames (sink.onAssetData), not just size-counted.
+ *  - `retainAssets` option: the worker-relay path keeps bitmaps/ImageData for
+ *    postMessage transfer (bench behavior); the main-thread manager passes
+ *    false so per-draw dynamic-source assets do not accumulate in memory.
+ *  - Untracked-context + context-created notifiers so the production manager
+ *    can discover contexts created BEFORE hooks installed (first method call
+ *    after install) and AFTER (getContext auto-attach path).
+ *  - DiscardSink short-circuit: in video mode the recorder stays attached
+ *    purely for dirtiness; ops are dropped BEFORE argument serialization.
+ */
+import { type MaskRegion, type RedactStyle } from "./canvasPrivacy";
+import { type AssetMode, type CapturedAsset, type EncodeImageFn, type RecorderSink, type StateSnapshot } from "./protocol";
+export { BufferSink, serializeTypedArray, deserializeTypedArray, TYPED_ARRAY_KINDS, } from "./protocol";
+export type { AssetMode, CapturedAsset, RecordedOp, RecorderSink, SerializedArg, StateSnapshot, } from "./protocol";
+export declare function notePreAttachMaskUsed(canvas?: HTMLCanvasElement | null): void;
+export declare function wasPreAttachMaskUsed(canvas?: HTMLCanvasElement | null): boolean;
+export declare function ignore2DContext(ctx: object): void;
+export declare function setUntracked2DContextNotifier(fn: ((ctx: CanvasRenderingContext2D) => void) | null): void;
+/**
+ * Return the active recorder bound to a 2D context, or undefined when the
+ * context isn't being recorded (recording off, not yet attached, or a
+ * non-recorded canvas). Used by the `maskCanvasDraws` public API to toggle
+ * per-draw masking. Never throws.
+ */
+export declare function recorderForContext(ctx: object | null | undefined): ContextRecorder | undefined;
+export declare function setContextCreatedNotifier(fn: ((canvas: HTMLCanvasElement, type: string) => void) | null): void;
+/**
+ * Build-plugin-tier emulation: when auto-attach is armed (BEFORE app/scene
+ * code runs), every newly created 2D context gets a recorder with a buffering
+ * sink. attach() later swaps in the strategy's real sink and drains the
+ * buffer — so creation-time work (gradients, initial render) is captured,
+ * exactly like the production pre-app wrapper.
+ */
+export interface AutoAttachConfig {
+    now: () => number;
+    assetMode: AssetMode;
+    encodeImage: EncodeImageFn;
+    retainAssets?: boolean;
+}
+/** What kind of context each canvas created (set by the getContext patch). */
+export interface CanvasContextInfo {
+    type: string;
+    attrs?: Record<string, unknown>;
+}
+export declare function getContextInfo(canvas: HTMLCanvasElement): CanvasContextInfo | undefined;
+export declare function setAutoAttach(config: AutoAttachConfig | null): void;
+/** Drop the auto-created (still-buffering) recorder for one canvas the
+ * manager decided not to record — e.g. invisible canvases (Konva hit
+ * canvases) whose BufferSink would otherwise grow unbounded while they keep
+ * drawing. No-op once a strategy sink is bound. */
+export declare function releaseAutoRecorder(canvas: HTMLCanvasElement): void;
+/** Drop auto-created recorders that no strategy bound (e.g. probe canvases). */
+export declare function pruneUnboundRecorders(): void;
+export declare class ContextRecorder {
+    /** main-thread or OffscreenCanvas 2D context */
+    private ctx;
+    private sink;
+    private now;
+    private assetMode;
+    private encodeImage;
+    readonly assets: Map<number, CapturedAsset>;
+    /** dedupe static image sources by identity */
+    private assetBySource;
+    private pendingEncodes;
+    private props;
+    private stack;
+    /** accumulated main-thread ms spent in capture code */
+    cpuMs: number;
+    /** a strategy sink has been bound (vs still buffering) */
+    bound: boolean;
+    /** keep bitmaps/ImageData on assets for postMessage transfer (worker path) */
+    private retainAssets;
+    constructor(
+    /** main-thread or OffscreenCanvas 2D context */
+    ctx: {
+        getTransform(): DOMMatrix;
+    }, sink: RecorderSink, now: () => number, assetMode: AssetMode, encodeImage: EncodeImageFn, opts?: {
+        retainAssets?: boolean;
+    });
+    get rawCtx(): object;
+    /** Bind the strategy's sink, draining anything buffered since getContext. */
+    swapSink(sink: RecorderSink): void;
+    /**
+     * A26: register a captured asset's metadata, evicting the oldest entries when
+     * the per-recorder cap is exceeded (LRU; Map keeps insertion order). Eviction
+     * only happens on the non-retaining manager path — when retainAssets is true
+     * (worker relay) the full set is transferred at stop, so we never evict there.
+     */
+    private addAsset;
+    /**
+     * Draw-site stamp id for the NEXT recorded op (Phase 3b). Set synchronously
+     * by __sfDrawSite (canvasManager) when stamped app code calls
+     * `__sfds(ctx, id).method(...)` — the method call runs immediately after, in
+     * the same task, so a single pending slot is race-free. Consumed + cleared
+     * by the next recordCall/recordSet.
+     */
+    pendingSiteId?: string;
+    /**
+     * A13 — privacy text redactor. When set (canvasManager installs it for
+     * "redact" and "normal" canvases that have a privacy rule / content-detection
+     * flag off), the FIRST string argument of `fillText` / `strokeText` is passed
+     * through this fn BEFORE serialization, so the original drawn text never
+     * reaches the command stream. Returns the (possibly masked) replacement
+     * string; non-string args are never handed to it. Left undefined on the hot
+     * path for canvases with no privacy rule, so normal recording pays nothing.
+     */
+    textRedactor?: (text: string) => string;
+    /**
+     * Runtime per-draw masking (the `maskCanvasDraws` public API). While
+     * `maskDepth > 0`, EVERY recorded op is DROPPED — `fillRect`, path
+     * construction (`moveTo`/`lineTo`/`arc`/…), `fill`/`stroke`, `fillText`,
+     * `drawImage`, state setters — so the sensitive shape/geometry/text the app
+     * draws inside the wrapped block never reaches the command stream. This is the
+     * only way to sanitize SPECIFIC content within a canvas: DOM/selector masking
+     * is whole-`<canvas>` only (there are no sub-canvas elements to target).
+     */
+    maskDepth: number;
+    /**
+     * Set true the first time a draw is masked by `maskDepth`. The canvas manager
+     * polls this to keep the canvas in command mode (a masked canvas must never
+     * demote to video — video frames can't be cheaply region-blanked) and to wire
+     * `maskedRegions` into the keyframe capturer so the real pixels of masked
+     * content are blanked on every keyframe. Replay shows the baked redaction
+     * (recolored shapes / asterisks / bars) from the command stream.
+     */
+    hasMaskedDraws: boolean;
+    /**
+     * Resolved redaction style for masked ops — how masked TEXT (asterisks/bar) and
+     * SHAPES (color/block/remove) are baked into the command stream. Set by the
+     * manager from the global `maskCanvasText` config, and overridden per-block by
+     * `maskCanvasDraws(ctx, fn, opts)`.
+     */
+    redactStyle: RedactStyle;
+    /**
+     * Per-block "text only" flag (maskCanvasDraws `keepShapes:true`). While set
+     * inside a mask block, only TEXT ops are redacted; shapes/geometry are recorded
+     * normally. Default false (mask everything in the block).
+     */
+    textOnlyMask: boolean;
+    /**
+     * Accumulated device-space (canvas-pixel) bounding boxes of masked content
+     * since the last full-canvas clear. The keyframe capturer fills each with
+     * REDACTION_COLOR before encoding so the real masked pixels never ship. Bounded
+     * (oldest evicted past the cap) so an incremental canvas that never clears
+     * cannot grow it without limit.
+     */
+    readonly maskedRegions: MaskRegion[];
+    /**
+     * Set when a masked op's keyframe-blank region CANNOT be computed (a degenerate
+     * transform, or geometry with no trackable bounds such as `ctx.fill(path2d)`).
+     * The redaction is already baked into the command stream, so to avoid leaking
+     * the real pixels the manager polls this and SUPPRESSES pixel keyframes for the
+     * canvas (command-only replay) — safer than blanking the whole canvas on every
+     * keyframe. [audit C-NEW-1 / C2 / M-NEW-2]
+     */
+    keyframeUnsafe: boolean;
+    /** Running LOCAL-space (pre-transform) path bounds for the in-progress path,
+     * used to size the masked-region bbox + the synthetic block fillRect for
+     * `fill`/`stroke` inside a mask block. Reset on beginPath. */
+    private maskPathBounds;
+    private takePendingSiteId;
+    recordCall(op: string, args: unknown[]): void;
+    /**
+     * A34 — hot-path arg serialization. A plain loop instead of
+     * `args.map((a) => this.serializeArg(a, t))` to avoid allocating a new arrow
+     * closure on every recorded call. Primitives (number / string / boolean /
+     * null / undefined) are handled inline so the common all-primitive draw call
+     * (fillRect, lineTo, setTransform…) never enters the slower object-dispatch
+     * branch of serializeArg. Produces an array byte-identical to the old .map
+     * output for the codec — verified by canvasHotPathAlloc.test.ts. The output
+     * array itself is freshly allocated (the BufferSink / worker paths retain it,
+     * so it cannot be pooled), but the per-call closure garbage is eliminated.
+     */
+    private serializeArgs;
+    recordSet(prop: string, value: unknown): void;
+    /** Redact one op issued inside a mask block. */
+    private maskCall;
+    /** Record a shape op normally from inside a keepShapes block (text-only mask).
+     * A trimmed recordCall tail: maintains the save/restore shadow stack so later
+     * keyframe state snapshots stay correct. */
+    private recordPassthrough;
+    /** Push a non-empty masked region. Past the cap, COALESCE to the union bbox
+     * rather than evicting the oldest — dropping a region would leave its real
+     * (masked) pixels un-blanked on the kept keyframe (a leak). Coalescing
+     * over-blanks within the union but never under-blanks (privacy > fidelity for
+     * a pathological canvas that masks >cap draws without ever clearing). */
+    private pushRegion;
+    /**
+     * Bound the region list past the cap WITHOUT dropping coverage (dropping would
+     * leak) and WITHOUT a one-way ratchet to whole-canvas (a single growing union
+     * could never be cleared by a partial clearRect — audit C-NEW-2). Snap regions
+     * to a coarse GRID of tiles: bounded count, full coverage, and a later clear can
+     * still drop individual tiles (clipRegionsToClear). Falls back to a single union
+     * only when the canvas size is unknown (worker/synthetic ctx).
+     */
+    private coalesceRegions;
+    /** Push the keyframe-blank region for a MASKED op. A redaction was already
+     * baked into the command stream, so the pixels MUST be blanked — if the bbox
+     * couldn't be computed (degenerate transform, or unbounded geometry like
+     * `ctx.fill(path2d)` / a zero-area paint), flag the canvas keyframe-UNSAFE so
+     * the manager suppresses pixel keyframes (command-only replay) rather than
+     * blanking the whole canvas on every keyframe. [audit C-NEW-1 / M-NEW-2] */
+    private pushMaskRegion;
+    /** Clear accumulated masked regions — called by the manager when the canvas is
+     * resized (a `canvas.width`/`height` assignment, or a `reset()`, wipes all
+     * pixels, so the prior regions are stale and would over-blank fresh content).
+     *
+     * [audit H1 / Round 2] Also clears `keyframeUnsafe`. A full-canvas clear/resize
+     * wipes whatever unboundable masked content tripped the flag, so the canvas is
+     * safe to keyframe again. Without this, a canvas that hit ONE degenerate-bbox
+     * mask op and was THEN resized still suppressed pixel keyframes for life. NOTE:
+     * this is only effective when the resize lands BEFORE the pump reads the flag —
+     * once `suppressPixelCapture` latches `ctl.pixelSuppressed` (tearing down the
+     * keyframe capturer + any video encoder), there is no cheap resurrection, so an
+     * already-suppressed controller stays suppressed by design (a deliberate
+     * one-way safety tradeoff — resurrecting mid-session risks shipping the very
+     * pixels we suppressed). Resetting the flag here keeps the recorder-side state
+     * honest and avoids a needless suppression for the pre-pump resize race. */
+    resetMaskedRegions(): void;
+    /** A clearRect wiped the pixels in its (device-space) rect — drop every masked
+     * region FULLY CONTAINED by it so the next keyframe doesn't blank now-empty
+     * areas. Works for a full-canvas clear (all regions inside → all dropped, i.e.
+     * a reset), a sub-rect clear, AND a TRANSLATED/SCALED clear (the cleared rect is
+     * wherever it actually landed in device space). A region that only PARTIALLY
+     * overlaps the cleared rect is KEPT — its still-painted part must stay blanked
+     * (over-blank the cleared part; never leak). [audit M1/M2]
+     *
+     * [audit H5 / Round 2] Containment is only sound when the cleared rect is
+     * AXIS-ALIGNED in device space. Under a ROTATED/SKEWED CTM, clearRect clears a
+     * PARALLELOGRAM, but `transformedBox` gives its AABB — which is strictly LARGER
+     * than the true cleared area. A masked region tucked into an AABB corner that
+     * the rotated clear never actually touched would be (wrongly) judged contained
+     * and DROPPED → its still-painted pixels leak on the kept keyframe. The clear's
+     * AABB over-claiming coverage is the dangerous direction (dropping a region is
+     * irreversible), so for a non-axis-aligned CTM we DROP NOTHING — the regions
+     * stay and over-blank the (now-cleared) area on the next keyframe, which is
+     * privacy-safe. A pure translate/scale/flip (b==0 && c==0, or a==0 && d==0)
+     * keeps the exact-rect guarantee and still clips. */
+    private clipRegionsToClear;
+    /** Emit a synthetic recorded method call (bypasses the maskDepth gate). */
+    private emitSynthCall;
+    /** Emit a synthetic recorded property set (a color override). */
+    private emitSynthSetter;
+    /** Emit a redaction block (save → fillStyle=REDACTION_COLOR → fillRect →
+     * restore) over a LOCAL-space rect; replay applies the current transform. */
+    private emitRedactionBlock;
+    /** Update the running LOCAL (user-space) path bounds for a path-build op. */
+    private updatePathBounds;
+    /** LOCAL (user-space) rect of a paint op — for the block fillRect. */
+    private shapeLocalRect;
+    /** DEVICE-space region of a paint op (its accumulated keyframe-blank bbox). */
+    private shapeRegion;
+    /** Dest rect (user space) of a drawImage in any of its 3/5/9-arg forms. */
+    private drawImageDest;
+    /** Device-space region of a drawn-text arg (the keyframe-blank bbox). The box
+     * comes from the glyph ADVANCE width, so it's padded proportionally to the font
+     * size AND the transform's scale to cover italic / emoji ink overhang in device
+     * space (under-covering would leak a glyph sliver on the kept keyframe). */
+    private textRegionFor;
+    /** LOCAL-space rect of a drawn-text arg (for a bar / block). */
+    private textLocalRect;
+    /** Measure a drawn-text arg (width/ascent/descent + align/baseline), falling
+     * back to a font-size approximation when the context has no measureText (worker
+     * OffscreenCanvas always does; the test fake ctx does not). */
+    private textMetrics;
+    /** Parse the px size from the recorded `font` prop (fallback 12). */
+    private fontSizePx;
+    /** The canvas backing the context (null for the test fake / detached ctx). */
+    private canvasSize;
+    /** Current transform as a plain Mat2D (null when getTransform throws). */
+    private getMat;
+    /** per-recorder emission state for cross-context objects */
+    private objRefs;
+    snapshotState(): StateSnapshot;
+    settle(): Promise<void>;
+    /** [audit B6] In-flight encode count — exported for tests to assert the set
+     * stays bounded (auto-removes on completion) rather than growing per frame. */
+    pendingEncodeCount(): number;
+    /** [audit B6] Register an in-flight encode so settle() awaits it, and AUTO-REMOVE
+     * it on completion so `pendingEncodes` never grows unbounded over a long session
+     * of per-frame dynamic-source captures. The internal then/finally swallow keeps
+     * the tracking from raising an unhandled rejection (settle still observes the
+     * original promise's outcome via the snapshot). */
+    private trackEncode;
+    private readTransform;
+    private serializeArg;
+    /**
+     * Factory objects (gradients/patterns/paths) emit lazily into THIS stream
+     * on first use — a __create plus logged method calls; later uses emit only
+     * newly appended calls. Cross-context safe: every stream that references
+     * the object re-creates it locally under the same global id.
+     */
+    private serializeFactoryObject;
+    private captureImageData;
+    private captureImageSource;
+}
+/** A cross-origin/tainted canvas readback throws a DOMException named
+ * "SecurityError" (toDataURL / createImageBitmap on a tainted source). Match by
+ * name (and message as a belt-and-braces fallback) so unrelated asset failures
+ * — OOM, codec errors — do NOT get reported as taint. */
+export declare function isTaintError(e: unknown): boolean;
+/** Patch one 2D-context prototype (CanvasRenderingContext2D on the main
+ * thread, OffscreenCanvasRenderingContext2D inside workers). */
+export declare function patch2DProto(protoObj: object): void;
+/** Main-thread installation: 2D proto + getContext auto-attach + kind registry. */
+export declare function installCommandHooks(): void;
+/** Attach directly to a known 2D context (worker-side OffscreenCanvas path,
+ * or main-thread contexts created before the hooks were installed). */
+export declare function attachRecorderToContext(ctx: {
+    getTransform(): DOMMatrix;
+}, sink: RecorderSink, now: () => number, assetMode: AssetMode, encodeImage: EncodeImageFn, opts?: {
+    retainAssets?: boolean;
+}): ContextRecorder;
+export declare function attachRecorder(canvas: HTMLCanvasElement, sink: RecorderSink, now: () => number, assetMode: AssetMode, encodeImage: EncodeImageFn, opts?: {
+    retainAssets?: boolean;
+}): ContextRecorder | null;
+export declare function detachRecorder(canvas: HTMLCanvasElement): void;
+export declare function detachRecorderFromContext(ctx: object): void;
+/**
+ * Draw-site stamp routing (Phase 3b): when stamped app code calls
+ * `__sfds(ctx, id).fillRect(...)`, canvasManager's __sfDrawSite calls this
+ * with the 2D context object; if it has a recorder, the id rides the next op.
+ * Returns true when handled (ctx is a recorded 2D context).
+ */
+export declare function noteCtxPendingSiteId(ctx: object, id: string): boolean;

package/dist/types/canvas/patchGL.d.ts

@@ -0,0 +1,74 @@
+/**
+ * WebGL1/2 command capture — port of the validated bench core
+ * (test-applications/canvas-recorder-bench/src/capture/patchGL.ts;
+ * evanw/webgl-recorder lineage, binary-encoded). Creator calls intern their
+ * results via the same __create meta-op the 2D path uses, so the shared codec
+ * + replayer machinery handles GL streams unchanged.
+ *
+ * Replay fidelity is "deterministic on the same GPU/driver" — pixel keyframes
+ * remain the bit-exact truth, exactly like the 2D path.
+ *
+ * SDK adaptations: SSR-safe installation (no top-level globals), untracked-
+ * context notifier for contexts created before install, DiscardSink
+ * short-circuit, attachGLRecorderToContext for mid-stream attach.
+ */
+import { type RecorderSink } from "./protocol";
+type GL = WebGLRenderingContext | WebGL2RenderingContext;
+/**
+ * Draw-site stamp routing (Phase 3b): when stamped app code calls
+ * `__sfds(glctx, id).drawArrays(...)`, canvasManager's __sfDrawSite calls this
+ * with the GL context; if it has a recorder, the id rides the next op.
+ * Returns true when handled (ctx is a recorded GL context).
+ */
+export declare function noteGLPendingSiteId(ctx: object, id: string): boolean;
+export declare function setUntrackedGLContextNotifier(fn: ((ctx: GL) => void) | null): void;
+/**
+ * Build-plugin-tier auto-attach, mirroring the 2D path: when armed before
+ * scene/app code runs, every new WebGL(2) context gets a buffering recorder —
+ * shader compiles and geometry uploads happen at app init and MUST be in the
+ * stream or replay renders nothing.
+ */
+export interface GLAutoConfig {
+    now: () => number;
+}
+export declare function setGLAutoAttach(config: GLAutoConfig | null): void;
+export declare function pruneUnboundGLRecorders(): void;
+export declare class GLRecorder {
+    private now;
+    cpuMs: number;
+    bound: boolean;
+    rawCtx: GL | null;
+    /** ids for GL objects, scoped to this recorder's stream */
+    private refs;
+    private nextId;
+    private sink;
+    private pendingEncodes;
+    private assetBySource;
+    private nextAssetId;
+    private assetCount;
+    constructor(sink: RecorderSink, now: () => number);
+    /** Await pending texture-asset encodes so they ship before the stream stops
+     * (mirrors ContextRecorder.settle). The manager awaits this at teardown. */
+    settle(): Promise<void>;
+    /** [audit B6] Register an in-flight encode + auto-remove on completion so the
+     * set never grows unbounded. (then/finally swallow avoids unhandled rejection.) */
+    private trackEncode;
+    /** Capture a static GL texture source as an imagedata asset (dedup'd by source
+     * identity, bounded). Returns the asset ref to serialize; an unreadable /
+     * tainted / over-cap source returns `unsupported` (uncaptured → blank replay,
+     * the prior behavior). */
+    private captureTexSource;
+    /** Bind the strategy's sink, draining anything buffered since getContext. */
+    swapSink(sink: RecorderSink): void;
+    /** draw-site stamp id for the next op (Phase 3b); see ContextRecorder.pendingSiteId */
+    pendingSiteId?: string;
+    recordCall(op: string, args: unknown[], result: unknown): void;
+    private arg;
+}
+export declare function installGLHooks(): void;
+export declare function attachGLRecorder(canvas: HTMLCanvasElement, contextType: string, sink: RecorderSink, now: () => number): GLRecorder | null;
+/** Mid-stream attach to a known GL context (created before hooks installed). */
+export declare function attachGLRecorderToContext(ctx: GL, sink: RecorderSink, now: () => number): GLRecorder;
+export declare function detachGLRecorder(canvas: HTMLCanvasElement, contextType: string): void;
+export declare function detachGLRecorderFromContext(ctx: object): void;
+export {};

package/dist/types/canvas/patchWebGPU.d.ts

@@ -0,0 +1,37 @@
+/**
+ * WebGPU command capture via object-graph proxying — capture-side port of the
+ * validated bench core (test-applications/canvas-recorder-bench/src/capture/
+ * patchWebGPU.ts; webgpu_recorder lineage). navigator.gpu and every object
+ * reachable from it (adapter, device, queue, encoders, pipelines, textures,
+ * views...) are wrapped in recording proxies. Method calls/property hops are
+ * logged as meta-ops with interned result ids; descriptors serialize as JSON
+ * with {__sfRef} markers for object references; buffer payloads ride the
+ * typed-array tag.
+ *
+ * Replay (player-side, NOT ported here) re-executes the op list against a
+ * fresh adapter/device with the recorded canvas context bound to the replay
+ * target. Deterministic on the same GPU; pixel keyframes remain the bit-exact
+ * truth (hybrid).
+ *
+ * SDK adaptations: SSR-safe installation, DiscardSink short-circuit (video
+ * demotion keeps dirtiness with zero serialize cost), swapGPUSink for the
+ * manager, replayGPU dropped (player concern).
+ */
+import { type RecorderSink } from "./protocol";
+interface GPUAutoConfig {
+    now: () => number;
+}
+export declare function setGPUDeviceLostNotifier(fn: ((lost: boolean) => void) | null): void;
+export declare function setGPUAutoAttach(config: GPUAutoConfig | null): void;
+export declare function pruneUnboundGPURecorders(): void;
+/** The canvas (if any) that created a webgpu context while armed. */
+export declare function getGPURecordedCanvas(): HTMLCanvasElement | null;
+export declare function installGPUHooks(): void;
+export interface GPURecorderHandle {
+    detach(): void;
+    cpuMs(): number;
+}
+export declare function attachGPURecorder(canvas: HTMLCanvasElement, strategySink: RecorderSink, now: () => number): GPURecorderHandle | null;
+/** Swap the page-global GPU sink (manager demotion path). */
+export declare function swapGPUSink(s: RecorderSink): void;
+export {};

package/dist/types/canvas/piiDetect.d.ts

@@ -0,0 +1,60 @@
+/**
+ * A13 — content-level PII detection + redaction shared between the rrweb input
+ * masker (`maskInputFn` in recording.tsx) and the canvas text path
+ * (`canvasPrivacy.ts`). Extracted so both call sites use ONE implementation of
+ * the credit-card / SSN / DOB detectors and their partial-mask formats.
+ *
+ * The "record*" flags are INVERTED privacy intent: `recordCreditCardInfo:false`
+ * means "do NOT record credit-card content" → redact it. A flag that is TRUE
+ * (or undefined → treated as record-everything for that type) leaves the
+ * matching content untouched. This mirrors the historical maskInputFn behavior,
+ * which always partial-masked detected CC/SSN content regardless of flags; here
+ * the canvas path gates on the flags so an account that explicitly opts INTO
+ * recording a PII type is honored.
+ *
+ * SSR rule: pure string functions, no window/document/navigator access. Safe to
+ * import at module scope anywhere.
+ */
+/**
+ * Luhn checksum over the digits of a candidate credit-card string. Accepts the
+ * raw matched substring (may contain spaces/hyphens) OR a pre-stripped digit
+ * string. Returns false for anything without 13–16 digits so non-card numbers
+ * (phones, SKUs) that happen to match the candidate regex are rejected.
+ */
+export declare function passesLuhn(digits: string): boolean;
+/**
+ * True when `s` contains a 13–16 digit run that ALSO passes the Luhn check.
+ * The Luhn gate removes the vast majority of false positives (phone numbers,
+ * order ids) the bare digit-run regex would otherwise flag.
+ */
+export declare function looksLikeCreditCard(s: string): boolean;
+/** True when `s` contains a `NNN-NN-NNNN` SSN-formatted run. */
+export declare function looksLikeSsn(s: string): boolean;
+/** True when `s` contains a `D/M/Y`-style date (any of `/ - .` separators). */
+export declare function looksLikeDob(s: string): boolean;
+/** "**** **** **** "+last4 — the historical maskInputFn credit-card format. */
+export declare function redactCreditCard(s: string): string;
+/** "***-**-"+last4 — the historical maskInputFn SSN format. */
+export declare function redactSsn(s: string): string;
+/** DOB partial mask: two masked groups + "/" + last 4 chars. */
+export declare function redactDob(s: string): string;
+export interface SensitiveContentFlags {
+    /** when FALSE, credit-card content is redacted */
+    recordCreditCardInfo?: boolean;
+    /** when FALSE, SSN content is redacted */
+    recordSsn?: boolean;
+    /** when FALSE, DOB content is redacted */
+    recordDob?: boolean;
+}
+/**
+ * Apply the partial-mask redactions to every PII match in `text`, but ONLY for
+ * the flags that are explicitly FALSE (privacy intent: "do not record this PII
+ * type"). A flag that is `true` or `undefined` leaves that PII type intact.
+ * Returns the original string when nothing matched or every relevant flag is on.
+ *
+ * Each enabled redactor replaces ALL of its matches in the string (a line like
+ * "DOB 01/02/1990 card 4111 1111 1111 1111" redacts both). Order:
+ * credit-card → SSN → DOB so a CC's internal digits are masked before the DOB
+ * pass scans (the partial-mask output contains no date-shaped runs).
+ */
+export declare function redactSensitiveContent(text: string, flags: SensitiveContentFlags): string;