@offscript/sdk 0.0.0-stage → 0.1.0

package/dist/core/OffscriptSDK.d.ts

@@ -0,0 +1,98 @@
+import type { OffscriptConfig, ResolvedConfig } from "../types/config";
+import { type EventKind, type OffscriptEvent, type RecordedAction } from "../types/events";
+import type { OffscriptState, RecordingStatus, SessionInfo, StartRecordingOptions, StopSummary } from "../types/session";
+import { DataSanitizer } from "../privacy/DataSanitizer";
+import type { EmitOptions, EventSink } from "../recorders/types";
+import { OffscriptError } from "../utils/errors";
+import { type PlaywrightRecording } from "../playwright/PlaywrightDataContract";
+export type OffscriptEventMap = {
+    statusChange: {
+        from: RecordingStatus;
+        to: RecordingStatus;
+    };
+    error: OffscriptError | Error;
+    sessionStart: SessionInfo;
+    sessionEnd: StopSummary;
+    flush: {
+        events: number;
+        batchId: string;
+        duplicate: boolean;
+    };
+    overflow: {
+        dropped: number;
+    };
+    disabled: {
+        reason?: string;
+    };
+};
+export declare class Offscript implements EventSink {
+    private readonly bus;
+    readonly config: ResolvedConfig;
+    readonly sanitizer: DataSanitizer;
+    private status;
+    private lastError?;
+    private sessions;
+    private transport?;
+    private lifecycle?;
+    private recorders;
+    private rrweb?;
+    private actions?;
+    private context?;
+    private accepting;
+    private initPromise?;
+    private startPromise?;
+    private stopPromise?;
+    private destroyed;
+    private recent;
+    private actionLog;
+    private contextLog;
+    private eventCount;
+    private metrics;
+    constructor(config: OffscriptConfig);
+    getState(): OffscriptState;
+    getMetrics(): {
+        emitted: number;
+        dropped: number;
+        avgEmitMs: number;
+        bufferKind?: string;
+    };
+    /** Idempotente. Prepara armazenamento/transporte e retoma sessão persistida (reload/MPA). */
+    init(): Promise<void>;
+    private doInit;
+    startRecording(opts: StartRecordingOptions): Promise<SessionInfo>;
+    private doStart;
+    private resumePersisted;
+    pauseRecording(): Promise<void>;
+    resumeRecording(): Promise<void>;
+    stopRecording(): Promise<StopSummary>;
+    private doStop;
+    /**
+     * Libera todos os recursos. Por padrão encerra a gravação ativa; com `{ complete: false }` apenas
+     * desanexa a instrumentação e mantém a sessão persistida para ser retomada por outra instância.
+     */
+    destroy(opts?: {
+        complete?: boolean;
+    }): Promise<void>;
+    /** Dados estruturados para o motor Playwright, construídos a partir do que foi gravado nesta página. */
+    exportPlaywrightData(): PlaywrightRecording;
+    getRecordedActions(): readonly RecordedAction[];
+    on<K extends keyof OffscriptEventMap>(type: K, fn: (payload: OffscriptEventMap[K]) => void): () => void;
+    off<K extends keyof OffscriptEventMap>(type: K, fn: (payload: OffscriptEventMap[K]) => void): void;
+    /** Usado pelos recorders. Não confundir com os eventos públicos (`on`). */
+    emit<T>(kind: EventKind, data: T, opts?: EmitOptions): OffscriptEvent<T> | null;
+    private record;
+    private correlate;
+    private emitLifecycle;
+    private attach;
+    private startRecorders;
+    private stopRecorders;
+    private teardown;
+    private onHeartbeat;
+    /** Backend desativou a gravação: encerra com flush de melhor esforço. */
+    private shutdownRemote;
+    private onFatal;
+    private fail;
+    private setStatus;
+    private debug;
+    static readonly version = "0.1.0";
+}

package/dist/core/SessionManager.d.ts

@@ -0,0 +1,44 @@
+import type { ResolvedConfig } from "../types/config";
+import type { CreateSessionResponse, HeartbeatResponse, PersistedSessionState, SessionInfo, StartRecordingOptions } from "../types/session";
+import { ApiClient } from "./ApiClient";
+/**
+ * Identidade da sessão, persistência por aba (sessionStorage), sequência e heartbeat.
+ *
+ * Política multi-aba: cada aba grava de forma independente na MESMA sessão/execução, com `tabId`
+ * próprio e sequência própria. A ordem canônica é (tabId, sequence); entre abas usa-se o timestamp.
+ * Abas clonadas (window.open copia o sessionStorage) recebem um novo tabId via Web Locks quando disponível.
+ */
+export declare class SessionManager {
+    private readonly cfg;
+    private state;
+    private info;
+    private seq;
+    private heartbeatTimer?;
+    private token;
+    private readonly storageKey;
+    private readonly seqKey;
+    readonly api: ApiClient;
+    disabledReason?: string;
+    constructor(cfg: ResolvedConfig);
+    get session(): SessionInfo | null;
+    get tabId(): string | undefined;
+    get currentToken(): string;
+    loadPersisted(): PersistedSessionState | null;
+    private persist;
+    setStatus(status: "recording" | "paused"): void;
+    clearPersisted(): void;
+    nextSequence(): number;
+    get lastSequence(): number;
+    /** Sobe a sequência até pelo menos `n` (ex.: maior sequência encontrada no buffer). */
+    ensureSequenceAtLeast(n: number): void;
+    newPage(): string;
+    get pageCount(): number;
+    /** Cria (ou obtém, de forma idempotente) a sessão no backend. */
+    create(opts: StartRecordingOptions, context: Record<string, unknown>): Promise<CreateSessionResponse>;
+    /** Reidrata sessão persistida (reload/navegação MPA) após validar no backend. */
+    resume(state: PersistedSessionState): Promise<HeartbeatResponse>;
+    startHeartbeat(onResult: (r: HeartbeatResponse) => void, onError: (e: unknown) => void, pending: () => number, status: () => string): void;
+    stopHeartbeat(): void;
+    complete(summary: Record<string, unknown>): Promise<boolean>;
+    reset(): void;
+}

package/dist/core/config.d.ts

@@ -0,0 +1,2 @@
+import { type OffscriptConfig, type ResolvedConfig } from "../types/config";
+export declare function resolveConfig(input: OffscriptConfig): ResolvedConfig;

package/dist/index.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var chunkHAPNSHFG_cjs = require('./chunk-HAPNSHFG.cjs');
+var chunk3NX2AGXM_cjs = require('./chunk-3NX2AGXM.cjs');
+var chunkB6GO5FE5_cjs = require('./chunk-B6GO5FE5.cjs');
+
+
+
+Object.defineProperty(exports, "createOffscript", {
+  enumerable: true,
+  get: function () { return chunkHAPNSHFG_cjs.createOffscript; }
+});
+Object.defineProperty(exports, "startOffscript", {
+  enumerable: true,
+  get: function () { return chunkHAPNSHFG_cjs.startOffscript; }
+});
+Object.defineProperty(exports, "AuthError", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.AuthError; }
+});
+Object.defineProperty(exports, "ConfigError", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.ConfigError; }
+});
+Object.defineProperty(exports, "DEFAULT_PRIVACY", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.DEFAULT_PRIVACY; }
+});
+Object.defineProperty(exports, "DEFAULT_RECORDING", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.DEFAULT_RECORDING; }
+});
+Object.defineProperty(exports, "DEFAULT_TRANSPORT", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.DEFAULT_TRANSPORT; }
+});
+Object.defineProperty(exports, "DataSanitizer", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.DataSanitizer; }
+});
+Object.defineProperty(exports, "InvalidStateError", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.InvalidStateError; }
+});
+Object.defineProperty(exports, "Offscript", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.Offscript; }
+});
+Object.defineProperty(exports, "OffscriptError", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.OffscriptError; }
+});
+Object.defineProperty(exports, "SessionDisabledError", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.SessionDisabledError; }
+});
+Object.defineProperty(exports, "SessionExpiredError", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.SessionExpiredError; }
+});
+Object.defineProperty(exports, "TransportError", {
+  enumerable: true,
+  get: function () { return chunk3NX2AGXM_cjs.TransportError; }
+});
+Object.defineProperty(exports, "ACTION_SCHEMA_VERSION", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.ACTION_SCHEMA_VERSION; }
+});
+Object.defineProperty(exports, "PLAYWRIGHT_CONTRACT_VERSION", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.PLAYWRIGHT_CONTRACT_VERSION; }
+});
+Object.defineProperty(exports, "SCHEMA_VERSION", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.SCHEMA_VERSION; }
+});
+Object.defineProperty(exports, "SDK_VERSION", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.SDK_VERSION; }
+});
+Object.defineProperty(exports, "SelectorGenerator", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.SelectorGenerator; }
+});
+Object.defineProperty(exports, "buildPlaywrightContract", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.buildPlaywrightContract; }
+});
+Object.defineProperty(exports, "normalizeActions", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.normalizeActions; }
+});
+Object.defineProperty(exports, "validatePlaywrightContract", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.validatePlaywrightContract; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { Offscript } from "./core/OffscriptSDK";
+export type { OffscriptEventMap } from "./core/OffscriptSDK";
+export * from "./types/config";
+export * from "./types/events";
+export * from "./types/session";
+export { OffscriptError, ConfigError, AuthError, SessionExpiredError, SessionDisabledError, InvalidStateError, TransportError, } from "./utils/errors";
+export type { OffscriptErrorCode } from "./utils/errors";
+export { DataSanitizer } from "./privacy/DataSanitizer";
+export { buildPlaywrightContract, validatePlaywrightContract, PLAYWRIGHT_CONTRACT_VERSION } from "./playwright/PlaywrightDataContract";
+export type { PlaywrightRecording, PlaywrightStep } from "./playwright/PlaywrightDataContract";
+export { normalizeActions } from "./playwright/ActionNormalizer";
+export { SelectorGenerator } from "./playwright/SelectorGenerator";
+export { createOffscript, startOffscript } from "./adapters/vanilla";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createOffscript, startOffscript } from './chunk-MBYNQSKA.js';
+export { AuthError, ConfigError, DEFAULT_PRIVACY, DEFAULT_RECORDING, DEFAULT_TRANSPORT, DataSanitizer, InvalidStateError, Offscript, OffscriptError, SessionDisabledError, SessionExpiredError, TransportError } from './chunk-3OSCH7J2.js';
+export { ACTION_SCHEMA_VERSION, PLAYWRIGHT_CONTRACT_VERSION, SCHEMA_VERSION, SDK_VERSION, SelectorGenerator, buildPlaywrightContract, normalizeActions, validatePlaywrightContract } from './chunk-LFXHB4PN.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/playwright/ActionNormalizer.d.ts

@@ -0,0 +1,37 @@
+import type { RecordedAction } from "../types/events";
+export type StepType = "click" | "dblclick" | "fill" | "press" | "select" | "check" | "uncheck" | "hover" | "drag" | "scroll" | "navigate" | "reload";
+export interface NormalizedStep {
+    type: StepType;
+    timestamp: number;
+    url: string;
+    selector?: string;
+    selectorUnique?: boolean;
+    selectorCandidates?: RecordedAction["selectorCandidates"];
+    element?: RecordedAction["element"];
+    coordinates?: {
+        x: number;
+        y: number;
+    };
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    args?: Record<string, unknown>;
+    expectsNavigation?: {
+        to: string;
+    };
+    sourceActionIds: string[];
+    causedByActionId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Converte ações brutas em passos semânticos mínimos, sem perder rastreabilidade:
+ *  - click, click, dblclick  → dblclick
+ *  - click em checkbox/radio + check → check/uncheck
+ *  - vários input no mesmo campo → um único fill
+ *  - input + Enter → fill + press
+ *  - focus/blur/mousemove/hover isolados são descartados (preservados apenas nos eventos brutos)
+ *  - scrolls consecutivos no mesmo alvo → um scroll
+ *  - navigate logo após click/Enter → vira `expectsNavigation` do passo causador
+ */
+export declare function normalizeActions(actions: readonly RecordedAction[]): NormalizedStep[];

package/dist/playwright/PlaywrightDataContract.d.ts

@@ -0,0 +1,88 @@
+import type { ActionType, ContextEventData, RecordedAction, SelectorCandidate } from "../types/events";
+import { type NormalizedStep } from "./ActionNormalizer";
+/**
+ * Contrato versionado entre o SDK e o futuro motor de automação (serviço externo).
+ * O SDK NÃO executa Playwright. Uma reprodução bem-sucedida dos passos não equivale a aprovação do teste:
+ * assertions continuam vinculadas aos casos de teste no painel.
+ */
+export declare const PLAYWRIGHT_CONTRACT_VERSION = "1.0";
+export declare const PLAYWRIGHT_CONTRACT_KIND = "offscript.playwright-recording";
+export interface PlaywrightStep {
+    index: number;
+    type: NormalizedStep["type"];
+    timestamp: number;
+    /** Intervalo desde o passo anterior (ms), limitado a 30s. */
+    waitBeforeMs: number;
+    url: string;
+    /** Melhor seletor (sintaxe Playwright) e alternativas em ordem de preferência. */
+    selector?: string;
+    selectorUnique?: boolean;
+    selectorCandidates?: SelectorCandidate[];
+    element?: RecordedAction["element"];
+    coordinates?: {
+        x: number;
+        y: number;
+    };
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Parâmetros do passo (valor permitido, tecla, destino...). Valores sensíveis chegam como `valueRef`. */
+    args?: Record<string, unknown>;
+    /** Navegação esperada após este passo. */
+    expectsNavigation?: {
+        to: string;
+    };
+    /** Rastreabilidade para investigação: ações brutas que originaram o passo. */
+    sourceActionIds: string[];
+    causedByActionId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface PlaywrightRecording {
+    contractVersion: string;
+    kind: typeof PLAYWRIGHT_CONTRACT_KIND;
+    generatedAt: number;
+    sdkVersion: string;
+    session: {
+        sessionId: string;
+        executionId: string;
+        testCaseId: string;
+        platformId: string;
+    };
+    initialConditions: {
+        url?: string;
+        viewport?: {
+            width: number;
+            height: number;
+        };
+        userAgent?: string;
+        language?: string;
+        timezone?: string;
+        deviceScaleFactor?: number;
+        browser?: {
+            name?: string;
+            version?: string;
+        };
+    };
+    steps: PlaywrightStep[];
+    stats: {
+        rawActions: number;
+        steps: number;
+        merged: number;
+    };
+    limitations: string[];
+    /** Campo livre para extensões compatíveis. */
+    extensions?: Record<string, unknown>;
+}
+export declare const CONTRACT_LIMITATIONS: string[];
+export interface BuildInput {
+    session: PlaywrightRecording["session"];
+    actions: readonly RecordedAction[];
+    contexts?: readonly ContextEventData[];
+    extensions?: Record<string, unknown>;
+}
+/** Constrói o contrato a partir das ações gravadas. Pode ser usado no navegador ou no backend. */
+export declare function buildPlaywrightContract(input: BuildInput): PlaywrightRecording;
+/** Validação estrutural do contrato (usada em testes e por consumidores). Retorna a lista de problemas. */
+export declare function validatePlaywrightContract(c: unknown): string[];
+export type { ActionType };

package/dist/playwright/SelectorGenerator.d.ts

@@ -0,0 +1,26 @@
+import type { ElementDescriptor, SelectorCandidate } from "../types/events";
+export interface SelectorOptions {
+    testIdAttributes: string[];
+    stableAttributes: string[];
+}
+export interface SelectorResult {
+    selector: string;
+    unique: boolean;
+    candidates: SelectorCandidate[];
+}
+export declare function isStableId(id: string): boolean;
+export declare function isStableClass(c: string): boolean;
+export declare function implicitRole(el: Element): string | undefined;
+export declare function labelText(el: Element): string;
+/** Nome acessível simplificado (aria-labelledby, aria-label, label, alt, title, conteúdo). */
+export declare function accessibleName(el: Element): string;
+export declare class SelectorGenerator {
+    private readonly opts;
+    constructor(opts: SelectorOptions);
+    generate(el: Element): SelectorResult;
+    private countRole;
+    private countByLabel;
+    /** CSS estrutural: ancora no ancestral estável mais próximo; usa tag + classes estáveis + nth-of-type. */
+    structuralCss(el: Element): string;
+    describe(el: Element): ElementDescriptor;
+}

package/dist/playwright/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./PlaywrightDataContract";
+export * from "./ActionNormalizer";
+export * from "./SelectorGenerator";

package/dist/playwright.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+var chunkB6GO5FE5_cjs = require('./chunk-B6GO5FE5.cjs');
+
+
+
+Object.defineProperty(exports, "CONTRACT_LIMITATIONS", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.CONTRACT_LIMITATIONS; }
+});
+Object.defineProperty(exports, "PLAYWRIGHT_CONTRACT_KIND", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.PLAYWRIGHT_CONTRACT_KIND; }
+});
+Object.defineProperty(exports, "PLAYWRIGHT_CONTRACT_VERSION", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.PLAYWRIGHT_CONTRACT_VERSION; }
+});
+Object.defineProperty(exports, "SelectorGenerator", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.SelectorGenerator; }
+});
+Object.defineProperty(exports, "accessibleName", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.accessibleName; }
+});
+Object.defineProperty(exports, "buildPlaywrightContract", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.buildPlaywrightContract; }
+});
+Object.defineProperty(exports, "implicitRole", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.implicitRole; }
+});
+Object.defineProperty(exports, "isStableClass", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.isStableClass; }
+});
+Object.defineProperty(exports, "isStableId", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.isStableId; }
+});
+Object.defineProperty(exports, "labelText", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.labelText; }
+});
+Object.defineProperty(exports, "normalizeActions", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.normalizeActions; }
+});
+Object.defineProperty(exports, "validatePlaywrightContract", {
+  enumerable: true,
+  get: function () { return chunkB6GO5FE5_cjs.validatePlaywrightContract; }
+});
+//# sourceMappingURL=playwright.cjs.map
+//# sourceMappingURL=playwright.cjs.map

package/dist/playwright.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"playwright.cjs"}

package/dist/playwright.js

@@ -0,0 +1,3 @@
+export { CONTRACT_LIMITATIONS, PLAYWRIGHT_CONTRACT_KIND, PLAYWRIGHT_CONTRACT_VERSION, SelectorGenerator, accessibleName, buildPlaywrightContract, implicitRole, isStableClass, isStableId, labelText, normalizeActions, validatePlaywrightContract } from './chunk-LFXHB4PN.js';
+//# sourceMappingURL=playwright.js.map
+//# sourceMappingURL=playwright.js.map

package/dist/playwright.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"playwright.js"}

package/dist/privacy/DataSanitizer.d.ts

@@ -0,0 +1,32 @@
+import type { CapturedBody, SelectorCandidate } from "../types/events";
+import type { PrivacyConfig } from "../types/config";
+export declare const REDACTED = "[REDACTED]";
+/**
+ * Sanitização feita ANTES de qualquer persistência ou envio.
+ * Todas as funções são puras e nunca lançam.
+ */
+export declare class DataSanitizer {
+    private readonly cfg;
+    private readonly headerSet;
+    private readonly extraKeys;
+    constructor(cfg: PrivacyConfig);
+    isSensitiveKey(key: string): boolean;
+    /** Mascara padrões sensíveis em texto livre (JWT, Bearer, CPF, CNPJ, cartões). */
+    scrubString(input: string): string;
+    sanitizeHeaders(headers: Record<string, string>): Record<string, string>;
+    /** Redige query params sensíveis e credenciais embutidas (user:pass@). */
+    sanitizeUrl(raw: string, base?: string): string;
+    /** Redige query/fragmento de um valor de atributo de URL preservando a forma original (relativa ou absoluta). */
+    redactUrlAttribute(value: string): string;
+    parseQuery(raw: string): Record<string, string | string[]> | undefined;
+    /** Redação profunda de objetos (chaves sensíveis + padrões em strings). */
+    sanitizeValue(value: unknown, depth?: number): unknown;
+    /** Converte um corpo textual em CapturedBody sanitizado, respeitando o limite. */
+    sanitizeTextBody(text: string, contentType: string, size?: number): CapturedBody;
+    isTextual(contentType: string): boolean;
+    isIgnoredUrl(url: string): boolean;
+    /** Referência opaca para valores não autorizados. */
+    redactedRef(value: string, salt: string): string;
+    /** Remove valores de atributos de seletor que podem conter dados sensíveis. */
+    sanitizeSelectorCandidates(list: SelectorCandidate[]): SelectorCandidate[];
+}

package/dist/privacy/PrivacyConfig.d.ts

@@ -0,0 +1,4 @@
+import { type PrivacyConfig } from "../types/config";
+export declare function resolvePrivacy(user?: Partial<PrivacyConfig>): PrivacyConfig;
+export declare const BASE_SENSITIVE_HEADERS: string[];
+export declare const BASE_SENSITIVE_KEY_PATTERN: RegExp;

package/dist/recorders/ActionRecorder.d.ts

@@ -0,0 +1,46 @@
+import { type RecordedAction } from "../types/events";
+import { type EventSink, type Recorder } from "./types";
+export type ActionDraft = Omit<RecordedAction, "id" | "sessionId" | "executionId" | "sequence" | "timestamp">;
+/** Ações semânticas do usuário. Eventos brutos → rascunhos de ação; a normalização é feita fora (ActionNormalizer). */
+export declare class ActionRecorder implements Recorder {
+    private readonly sink;
+    readonly name = "actions";
+    private d;
+    private gen;
+    private paused;
+    private pendingInput?;
+    private inputTimer?;
+    private salt;
+    private lastClick?;
+    private scrollState;
+    private hover?;
+    private drag?;
+    private move;
+    private moveFlush?;
+    constructor(sink: EventSink);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    /** Descarrega estados pendentes (input em edição, scroll, trajetória do mouse). */
+    flushAll(): void;
+    recordNavigation(from: string, to: string, kind: string): void;
+    recordPageLoad(navType: string | undefined, referrer: string): void;
+    private emit;
+    private target;
+    private onClick;
+    private onDblClick;
+    private onInput;
+    private flushInput;
+    private onChange;
+    private onKey;
+    private onFocus;
+    private onScroll;
+    private onOver;
+    private onOut;
+    private endHover;
+    private onDown;
+    private onUp;
+    private onMove;
+    private flushMove;
+}

package/dist/recorders/ContextRecorder.d.ts

@@ -0,0 +1,23 @@
+import { type ContextEventData } from "../types/events";
+import { type EventSink, type Recorder } from "./types";
+export interface ContextIdentity {
+    platformId: string;
+    testCaseId: string;
+    executionId: string;
+}
+export declare function parseBrowser(ua: string): {
+    name?: string;
+    version?: string;
+};
+export declare function collectContext(id: ContextIdentity, reason: ContextEventData["reason"], appVersion?: string): ContextEventData;
+/** Metadados de investigação. Sem fingerprinting: apenas dados já expostos e úteis ao QA. */
+export declare class ContextRecorder implements Recorder {
+    private readonly sink;
+    private readonly identity;
+    readonly name = "context";
+    private d;
+    constructor(sink: EventSink, identity: () => ContextIdentity);
+    start(): void;
+    record(reason: ContextEventData["reason"]): void;
+    stop(): void;
+}

package/dist/recorders/ErrorRecorder.d.ts

@@ -0,0 +1,20 @@
+import { type EventSink, type Recorder } from "./types";
+export declare function serializeArg(v: unknown, depth?: number, seen?: WeakSet<object>): unknown;
+export declare function firstFrame(stack?: string): {
+    file?: string;
+    line?: number;
+    column?: number;
+};
+/** Console + erros globais. Nunca altera argumentos, nem suprime saída, nem lança. */
+export declare class ErrorRecorder implements Recorder {
+    private readonly sink;
+    readonly name = "errors";
+    private d;
+    private busy;
+    constructor(sink: EventSink);
+    start(): void;
+    private report;
+    private wrapConsole;
+    private captureConsole;
+    stop(): void;
+}

package/dist/recorders/HTTPRecorder.d.ts

@@ -0,0 +1,28 @@
+import { type EventSink, type Recorder } from "./types";
+/**
+ * Instrumentação de fetch e XMLHttpRequest. Não altera assinatura, retorno, headers, credenciais,
+ * AbortController nem consome streams do usuário (usa clone/leitura limitada e apenas quando habilitado).
+ */
+export declare class HTTPRecorder implements Recorder {
+    private readonly sink;
+    private readonly ownApiUrl;
+    readonly name = "http";
+    private inflight;
+    private active;
+    private restore;
+    constructor(sink: EventSink, ownApiUrl: string);
+    start(): void;
+    stop(): void;
+    private isIgnored;
+    private patchFetch;
+    private beginFetch;
+    private endFetch;
+    private readBounded;
+    private failFetch;
+    private patchXhr;
+    private beginXhr;
+    private endXhr;
+    private base;
+    private emit;
+    private describeBody;
+}