@corbado/autocapture 1.0.1 → 1.2.0

package/dist/guards-Bwsr1zMi.d.ts

@@ -0,0 +1,351 @@
+import { p as NetworkBodyProjectionContext, l as HttpRequestStarted, H as HttpExchange, m as NavigationEvent, v as WebAuthnCeremonyEvent } from './types-lamU1Fd3.js';
+
+/** Capture depth of a surface. `values` applies the redaction rules; anything no rule names becomes its class. */
+type ProbeLevel = "off" | "inventory" | "shape" | "values";
+/** Everything a probe config can observe. */
+type ProbeSurface = "page" | "ui" | "act" | "nav" | "res" | "store" | "net" | "form" | "err" | "console" | "dl" | "msg" | "glob" | "cev";
+/**
+ * Redaction method of a rule.
+ *
+ * - `drop`: the key / element is left out.
+ * - `presence`: `<set>` or `<empty>`.
+ * - `length`: `<len:n>`.
+ * - `class`: a coarse class such as `<email>`, `<digits:6>`, `<alpha:5>`, `<uuid>`, `<text:4w>` (the default).
+ * - `shape`: format mask — digits → `9`, letters → `a`, separators kept; optional `keepPrefix`.
+ * - `hash`: `<h:…>`, salted per page (the salt never leaves the page).
+ * - `mask`: `*` for every character except `keepStart` / `keepEnd`.
+ * - `enum`: the value when it is one of `values`, its class otherwise.
+ * - `clear`: the value itself (still subject to the always-on guards).
+ */
+type ProbeMethod = "drop" | "presence" | "length" | "class" | "shape" | "hash" | "mask" | "enum" | "clear";
+/** Options shared by every surface. */
+type ProbeSurfaceConfig = {
+    level: ProbeLevel;
+};
+/** `net` surface options. */
+type ProbeNetSurfaceConfig = ProbeSurfaceConfig & {
+    /** Host globs to observe (default: every host except Corbado's own). */
+    hosts?: string[];
+    /** Host globs never observed (Corbado's own hosts are always excluded). */
+    excludeHosts?: string[];
+    /** Path globs to observe (default: every path). */
+    paths?: string[];
+    /** Uppercase methods to observe (default: all). */
+    methods?: string[];
+    /** Read and redact bodies at `shape` / `values` (default true). */
+    bodies?: boolean;
+};
+/** `res` surface options. */
+type ProbeResSurfaceConfig = ProbeSurfaceConfig & {
+    /** Host globs (default: all but Corbado's own). */
+    hosts?: string[];
+    /** Poll interval for new Resource Timing entries (default 5000 ms, min 1000). */
+    everyMs?: number;
+};
+/** `ui` surface options. */
+type ProbeUiSurfaceConfig = ProbeSurfaceConfig & {
+    /** Max distinct views per document (default 30). */
+    maxViews?: number;
+};
+/** `console` surface options. */
+type ProbeConsoleSurfaceConfig = ProbeSurfaceConfig & {
+    /** Console methods to observe (default `["error", "warn"]`). */
+    levels?: Array<"error" | "warn" | "info" | "log" | "debug">;
+};
+type ProbeSurfaces = {
+    page?: ProbeLevel | ProbeSurfaceConfig;
+    ui?: ProbeLevel | ProbeUiSurfaceConfig;
+    act?: ProbeLevel | ProbeSurfaceConfig;
+    nav?: ProbeLevel | ProbeSurfaceConfig;
+    res?: ProbeLevel | ProbeResSurfaceConfig;
+    store?: ProbeLevel | ProbeSurfaceConfig;
+    net?: ProbeLevel | ProbeNetSurfaceConfig;
+    form?: ProbeLevel | ProbeSurfaceConfig;
+    err?: ProbeLevel | ProbeSurfaceConfig;
+    console?: ProbeLevel | ProbeConsoleSurfaceConfig;
+    dl?: ProbeLevel | ProbeSurfaceConfig;
+    msg?: ProbeLevel | ProbeSurfaceConfig;
+    glob?: ProbeLevel | ProbeSurfaceConfig;
+    cev?: ProbeLevel | ProbeSurfaceConfig;
+};
+/** Method options (used by rules, snapshot fields and correlate values). */
+type ProbeMethodOptions = {
+    method: ProbeMethod;
+    /** `enum`: the values that may be emitted as they are. */
+    values?: string[];
+    /** `shape`: leading characters kept as they are. */
+    keepPrefix?: number;
+    /** `mask`: characters kept at the start / end. */
+    keepStart?: number;
+    keepEnd?: number;
+};
+/**
+ * One redaction rule. A rule applies when every scope it names matches; the first matching rule wins.
+ * Keys are compared case-insensitively with `-`, `_` and spaces ignored; a key containing `.` is a dotted
+ * path glob matched against the end of the value's path (`data.json_data.bound`, `*.assertion_id`).
+ */
+type ProbeRule = ProbeMethodOptions & {
+    surface?: ProbeSurface | ProbeSurface[];
+    /** Host globs of the URL the value belongs to (`net`, `res`, `page`, `nav`); the page host for DOM surfaces. */
+    host?: string | string[];
+    /** Path globs of that URL; the page path for DOM surfaces. */
+    path?: string | string[];
+    /** Key names or dotted path globs (body keys, query parameters, storage keys, form field names). */
+    key?: string | string[];
+    /** CSS selector (`ui`, `act`, `form`): applies to matching elements and their subtree. */
+    selector?: string;
+    /** `net` only: which part of the exchange. */
+    part?: "url" | "request" | "response";
+};
+/** Network matcher. */
+type ProbeNetMatch = {
+    host?: string | string[];
+    path?: string | string[];
+    method?: string | string[];
+    /** Status codes, or `ok` (2xx/3xx) / `error` (0, ≥ 400 or not loaded). Ignored at request time. */
+    status?: number[] | "ok" | "error";
+    /** Request body conditions: dotted path → expected value(s), compared as strings. */
+    body?: Record<string, string | string[]>;
+    /** Response body conditions (same form). */
+    response?: Record<string, string | string[]>;
+};
+/** Something that happens on the page: used by `trigger.on`, `snapshot.on` and `count.on`. */
+type ProbeMatch = {
+    net?: ProbeNetMatch;
+    /** A visible element matching this selector appears. */
+    selector?: string;
+    /** A click on (or inside) an element matching this selector. */
+    click?: string;
+    /** A form submit (`true` = any form, string = form selector). */
+    submit?: string | true;
+    /** `handle.signal(name)` from the host. */
+    signal?: string;
+    /** The host context (`deps.context().state`) enters this state. */
+    state?: string;
+    /** An uncaught error or unhandled rejection. */
+    error?: true;
+};
+/** A body value to read: dotted path (`[]` iterates arrays, `**` searches any depth; JSON strings are parsed). */
+type ProbePathPick = Partial<ProbeMethodOptions> & {
+    path: string;
+    /** Output name (default: the path). */
+    as?: string;
+};
+type ProbeSnapshotAction = {
+    type: "snapshot";
+    name: string;
+    on: ProbeMatch;
+    /** Form fields: value via `method` (default `class`), validity flags, `aria-invalid`, nearby error text. */
+    fields?: Array<Partial<ProbeMethodOptions> & {
+        selector: string;
+        as?: string;
+    }>;
+    /** Visible texts of these selectors (free-text redaction). */
+    texts?: string[];
+    /** Request / response body values (only when `on.net` matched). */
+    request?: ProbePathPick[];
+    response?: ProbePathPick[];
+    /** Max snapshots per document (default 20). */
+    max?: number;
+};
+/**
+ * Remember `key → value` pairs seen in one exchange and resolve the key in a later one, emitting only the
+ * value (e.g. an OTP send: the channel id never leaves the page, its channel type does).
+ */
+type ProbeCorrelateAction = {
+    type: "correlate";
+    name: string;
+    /** Item kind (default `corr`). */
+    kind?: string;
+    learn: {
+        net: ProbeNetMatch;
+        /** Body to learn from (default `response`). */
+        from?: "request" | "response";
+        /** Path of the objects to learn from (e.g. `**.channels[]`). */
+        items: string;
+        /** Path of the key inside an item (kept in memory only). */
+        key: string;
+        /** Path of the value inside an item. */
+        value: string;
+        /** How the value is emitted (default `enum` with `values`, else `class`). */
+        method?: ProbeMethod;
+        values?: string[];
+        /** Paths inside an item whose size is reported with the offered values (object keys / array length / 1). */
+        count?: string[];
+    };
+    resolve: {
+        net: ProbeNetMatch;
+        /** Body holding the key (default `request`). */
+        from?: "request" | "response";
+        /** Path(s) of the key; the first that resolves wins. */
+        key: string | string[];
+        /** Extra values emitted with the result. */
+        fields?: ProbePathPick[];
+    };
+    /** Max emissions per document (default 50). */
+    max?: number;
+};
+type ProbeCountAction = {
+    type: "count";
+    name: string;
+    on: ProbeMatch;
+};
+type ProbeAction = ProbeSnapshotAction | ProbeCorrelateAction | ProbeCountAction;
+/** Conditions; all must hold. */
+type ProbeWhen = {
+    /** Observe project ids (`deps.projectId`). */
+    projects?: string[];
+    /** ISO 8601 date or date-time; the probe is off after it. */
+    until?: string;
+    /** Fraction 0..1 of sessions, sticky per session id. */
+    sample?: number;
+    /** Browser names: `chrome`, `edge`, `safari`, `firefox`, `samsung`, `opera`, `other`. */
+    browser?: string[];
+    /** OS names: `windows`, `macos`, `ios`, `android`, `linux`, `chromeos`, `other`. */
+    os?: string[];
+    device?: Array<"desktop" | "mobile" | "tablet">;
+    /** Page path globs, evaluated per item. */
+    path?: string[];
+    /** Host context states (`deps.context().state`), evaluated per item. */
+    state?: string[];
+    /** Flow tags (`deps.tags()`): tag → allowed values (`*` = any). Items are buffered until the tag is known. */
+    tags?: Record<string, string[]>;
+    /** Integration version globs (`deps.integrationVersion`). */
+    integrationVersion?: string[];
+};
+/** Flight recorder: items are buffered and only sent when one of `on` happens. */
+type ProbeTrigger = {
+    on: ProbeMatch[];
+    /** Ring buffer size in items (default 300) and bytes (default 300000). */
+    buffer?: number;
+    bufferBytes?: number;
+    /** After a trigger, items stream directly for this long (default 30000 ms) before buffering resumes. */
+    streamMs?: number;
+};
+type ProbeBudgets = {
+    /** Items per document (default 400). */
+    items?: number;
+    /** Serialized bytes per document (default 400000). */
+    bytes?: number;
+    /** Items per document and kind (defaults per kind, e.g. `ui` 40, `act` 150, `net` 150). */
+    perKind?: Record<string, number>;
+};
+/** Probe configuration, schema version 1. */
+type ProbeConfig = {
+    v: 1;
+    /** Free label (not interpreted). */
+    name?: string;
+    when?: ProbeWhen;
+    trigger?: ProbeTrigger;
+    surfaces?: ProbeSurfaces;
+    rules?: ProbeRule[];
+    actions?: ProbeAction[];
+    budgets?: ProbeBudgets;
+};
+/** Host context stamped on items. */
+type ProbeItemContext = {
+    state?: string;
+    flowType?: string;
+    step?: string;
+};
+/** What the engine hands to the sink (→ `tracker.probe`). */
+type ProbeSinkItem = {
+    kind: string;
+    payload: Record<string, unknown> | unknown[];
+    pageId: string;
+    cfg: string;
+    ctx?: ProbeItemContext;
+    ts: number;
+};
+/**
+ * A network subscriber, shaped like autocapture-x's CaptureHub `NetworkSubscriber`: projectors run
+ * synchronously inside the network capture and are the only place raw bodies are seen.
+ */
+type ProbeNetworkSubscriber = {
+    id: string;
+    match(url: URL, method: string): boolean;
+    projectRequest?(body: unknown, context: NetworkBodyProjectionContext<"request">): unknown;
+    projectResponse?(body: unknown, context: NetworkBodyProjectionContext<"response">): unknown;
+    onRequest?(request: HttpRequestStarted<unknown>): void;
+    onExchange?(exchange: HttpExchange<unknown, unknown>): void;
+};
+/** CaptureHub-compatible network source: `{ subscribe: (s) => hub.subscribeNetwork(s) }`. */
+type ProbeNetworkSource = {
+    /** Called synchronously by `startProbes`; may return an unsubscribe function. */
+    subscribe(subscriber: ProbeNetworkSubscriber): (() => void) | void;
+};
+type ProbeNavigationSource = {
+    subscribe(listener: (event: NavigationEvent) => void): (() => void) | void;
+};
+type ProbeWebAuthnSource = {
+    subscribe(listener: (event: WebAuthnCeremonyEvent) => void): (() => void) | void;
+};
+type ProbeDeps = {
+    /** Receives every redacted item (→ `tracker.probe(item)`). */
+    sink(item: ProbeSinkItem): void;
+    projectId: string;
+    /** Network source; falls back to the package's own `captureNetwork` when absent. */
+    network?: ProbeNetworkSource;
+    /** Navigation source; falls back to `captureNavigation` when absent. */
+    navigation?: ProbeNavigationSource;
+    /** WebAuthn events, used only to taint ceremony values; none when absent. */
+    webauthn?: ProbeWebAuthnSource;
+    context?(): ProbeItemContext | undefined;
+    tags?(): Record<string, string> | undefined;
+    /** Session id for sticky sampling. */
+    sessionId?(): string | undefined;
+    /** For `when.integrationVersion`. */
+    integrationVersion?: string;
+    now?(): number;
+};
+type ProbeHandle = {
+    /** `active`: capturing; `off`: a condition does not hold or the config is invalid; `unavailable`: no page or another engine runs. */
+    readonly mode: "active" | "off" | "unavailable";
+    /** Config hash stamped on every item (`cfg`). */
+    readonly hash: string;
+    /** Why the probe is not active. */
+    readonly reason?: string;
+    /** Host-signalled event (e.g. a step error) for `trigger.on` / actions `{ signal }`. */
+    signal(name: string): void;
+    disconnect(): void;
+};
+
+/**
+ * Always-on guards. Not configurable: no config field reaches them.
+ *
+ * 1. Single DOM value read path: every field value read goes through {@link readFieldValue} /
+ *    {@link fieldValueLength}; sensitive fields (passwords, one-time codes, card fields, inputs of
+ *    WebAuthn-bound forms) yield at most their length.
+ * 2. Taint set: values that must never leave (typed passwords / OTPs, WebAuthn ceremony parts, cookie
+ *    values, Authorization headers) are kept as salted rolling hashes; any occurrence anywhere in an
+ *    item becomes `<tainted:len>`.
+ * 3. Pattern pass: JWT / JWE (any case), base64url WebAuthn client data, Luhn-valid card numbers,
+ *    WebAuthn / password keys, high-entropy tokens ≥ 24 chars.
+ * 4. Fail closed: a guard that throws drops the item.
+ */
+
+/** Salted rolling-hash fingerprints of values that must never leave. Values themselves are not kept. */
+declare class ProbeTaint {
+    private readonly base1;
+    private readonly base2;
+    private readonly byLength;
+    private readonly order;
+    constructor();
+    /** Number of fingerprints held. */
+    get size(): number;
+    /** Adds a value (and its URL-encoded / JSON-escaped forms). Values under 6 chars are ignored. */
+    add(value: unknown): void;
+    private addOne;
+    private fingerprint;
+    /** Replaces every tainted occurrence with `<tainted:len>`. */
+    scrub(text: string): string;
+}
+/** A fresh taint set (for tests / the conformance runner), optionally pre-filled. */
+declare function createProbeTaint(values?: string[]): ProbeTaint;
+/**
+ * The final always-on pass over an item: taint, pattern and key guards. Returns a guarded copy, or
+ * `undefined` when the pass fails (the item must then be dropped — fail closed).
+ */
+declare function applyGuards(item: unknown, taint?: ProbeTaint | null): unknown;
+
+export { type ProbeTrigger as A, type ProbeUiSurfaceConfig as B, type ProbeWebAuthnSource as C, type ProbeWhen as D, applyGuards as E, createProbeTaint as F, type ProbeConfig as P, type ProbeDeps as a, type ProbeHandle as b, type ProbeAction as c, type ProbeBudgets as d, type ProbeConsoleSurfaceConfig as e, type ProbeCorrelateAction as f, type ProbeCountAction as g, type ProbeItemContext as h, type ProbeLevel as i, type ProbeMatch as j, type ProbeMethod as k, type ProbeMethodOptions as l, type ProbeNavigationSource as m, type ProbeNetMatch as n, type ProbeNetSurfaceConfig as o, type ProbeNetworkSource as p, type ProbeNetworkSubscriber as q, type ProbePathPick as r, type ProbeResSurfaceConfig as s, type ProbeRule as t, type ProbeSinkItem as u, type ProbeSnapshotAction as v, type ProbeSurface as w, type ProbeSurfaceConfig as x, type ProbeSurfaces as y, ProbeTaint as z };

package/dist/index.d.mts

@@ -1,250 +1,7 @@
-import { WebAuthnIdentifierProjectors } from '@corbado/observe';
+import { W as WebAuthnCaptureOptions, a as WebAuthnCaptureHandle, F as FederatedIdentityCaptureOptions, b as FederatedIdentityCaptureHandle, N as NetworkCaptureOptions, C as CaptureHandle, c as NavigationCaptureOptions } from './types-lamU1Fd3.mjs';
+export { d as CredentialMediation, e as FederatedIdentityCompletedEvent, f as FederatedIdentityContext, g as FederatedIdentityEvent, h as FederatedIdentityFailedEvent, i as FederatedIdentityMode, j as FederatedIdentityProvider, k as FederatedIdentityStartedEvent, H as HttpExchange, l as HttpRequestStarted, L as Logger, m as NavigationEvent, n as NavigationSource, o as NetworkBodyDirection, p as NetworkBodyProjectionContext, q as NetworkBodyProjector, r as NetworkTransport, s as WebAuthnAttachSurface, t as WebAuthnCeremonyCompletedEvent, u as WebAuthnCeremonyContext, v as WebAuthnCeremonyEvent, w as WebAuthnCeremonyFailedEvent, x as WebAuthnCeremonyStartedEvent, y as WebAuthnMediation, z as WebAuthnUiMode } from './types-lamU1Fd3.mjs';
 export { WebAuthnIdentifierProjector, WebAuthnIdentifierProjectors, sanitizeAssertionResponse, sanitizeCreationOptions, sanitizeCreationResponse, sanitizeRequestOptions } from '@corbado/observe';
 
-/** Receives optional diagnostics. Capture functions remain silent when no logger is provided. */
-type Logger = {
-    /** Records a non-fatal diagnostic message. */
-    log: (...args: unknown[]) => void;
-};
-/** Controls a capture session. */
-type CaptureHandle = {
-    /**
-     * Result of starting the capture.
-     *
-     * - `"standard"`: capture started normally.
-     * - `"unavailable"`: capture could not be started and will not emit events.
-     */
-    readonly mode: "standard" | "unavailable";
-    /** Stops future event delivery. Safe to call more than once. */
-    disconnect(): void;
-};
-/** Normalized Credential Management mediation. Missing mediation defaults to `optional`. */
-type WebAuthnMediation = "silent" | "optional" | "conditional" | "required" | "unknown";
-/** Normalized Credential Management UI mode for authentication ceremonies. */
-type WebAuthnUiMode = "default" | "immediate" | "unknown";
-/** Browser-native facts that remain stable for one ceremony. */
-type WebAuthnCeremonyContext = {
-    kind: "authentication";
-    mediation: WebAuthnMediation;
-    uiMode: WebAuthnUiMode;
-    /** Whether the RP supplied a non-empty allow list or requested discoverable credentials. */
-    credentialSet: "allowlisted" | "discoverable";
-} | {
-    kind: "registration";
-    mediation: WebAuthnMediation;
-};
-type WebAuthnCeremonyBase = WebAuthnCeremonyContext & {
-    /** Identifier shared by all events belonging to the same ceremony. */
-    ceremonyId: string;
-};
-type WebAuthnCeremonyStartedEvent = WebAuthnCeremonyBase & {
-    phase: "started";
-    /** Whether transient user activation was active when the ceremony started, when exposed by the browser. */
-    userActivation?: boolean;
-    /**
-     * JSON-encoded authentication publicKey options. All fields are retained.
-     * Binary values are base64url-encoded. Treat this value as sensitive telemetry.
-     */
-    requestOptionsJson?: string;
-    /** Creation publicKey options with user.name and user.displayName removed. */
-    creationOptionsJson?: string;
-};
-type WebAuthnCeremonyCompletedEvent = WebAuthnCeremonyBase & {
-    phase: "completed";
-    /** JSON-encoded credential after the centralized blacklist; present only when applicable and serializable. Treat this value as sensitive telemetry. */
-    credentialJson?: string;
-    /** A credential manager may complete even after the ceremony signal was aborted. */
-    aborted?: true;
-};
-type WebAuthnCeremonyFailedEvent = WebAuthnCeremonyBase & {
-    phase: "failed";
-    /** Rejection value from the failed ceremony. This may contain application-specific data. */
-    error: unknown;
-    /** DOM exception name, or `UnknownError` when no name is available. */
-    errorName: string;
-    /** Present when the request signal was aborted before settlement. */
-    aborted?: true;
-};
-/** A protocol-native lifecycle event for WebAuthn authentication or registration. */
-type WebAuthnCeremonyEvent = WebAuthnCeremonyStartedEvent | WebAuthnCeremonyCompletedEvent | WebAuthnCeremonyFailedEvent;
-/**
- * Surface WebAuthn capture may attach to.
- *
- * - `"methods"`: `credentials.get` / `credentials.create` only.
- * - `"container"`: additionally the `navigator.credentials` container, used when the methods are
- *   held by another integration in a form that cannot be shared.
- */
-type WebAuthnAttachSurface = "methods" | "container";
-/** Options for {@link captureWebAuthn}. */
-type WebAuthnCaptureOptions = {
-    /** Receives WebAuthn lifecycle events. Return values are not awaited. */
-    onEvent: (event: WebAuthnCeremonyEvent) => void;
-    /** Optional diagnostic logger. */
-    logger?: Logger;
-    /**
-     * Synchronous SDK user identifier projection for creation user.id and response userHandle.
-     * Missing callbacks preserve user IDs; callback errors omit them. Credential IDs stay unchanged.
-     * Use the same projector in network fallback serializers.
-     * Projection affects telemetry only; authentication arguments, results and errors stay unchanged.
-     */
-    identifierProjectors?: WebAuthnIdentifierProjectors;
-    /**
-     * Highest surface capture may attach to. Defaults to `"methods"`.
-     *
-     * With `"container"`, a capture that cannot patch the methods attaches to the
-     * `navigator.credentials` container instead: reads of `get`/`create` are observed while the
-     * integration holding them keeps handling the ceremony. The methods surface is always tried
-     * first, so this changes nothing when it is available.
-     */
-    attach?: WebAuthnAttachSurface;
-};
-/**
- * Handle returned by {@link captureWebAuthn}.
- *
- * `surface` reports where the capture actually attached, which is not implied by `mode`: an
- * `attach: "container"` capture reports `mode: "standard"` from either surface.
- */
-type WebAuthnCaptureHandle = CaptureHandle & {
-    /** Surface this capture attached to; `"none"` when `mode` is `"unavailable"`. */
-    readonly surface: WebAuthnAttachSurface | "none";
-};
-/** Network API used for an observed exchange. */
-type NetworkTransport = "xhr" | "fetch";
-/** Direction of a projected body within an observed network exchange. */
-type NetworkBodyDirection = "request" | "response";
-/** A matched network request immediately after the platform accepted it. */
-type HttpRequestStarted<RequestBody = unknown> = {
-    /** Identifier shared with the eventual {@link HttpExchange}. */
-    requestId: string;
-    /** Network API used for the request. */
-    transport: NetworkTransport;
-    /** Uppercase HTTP method. */
-    method: string;
-    /** Resolved absolute request input URL. */
-    url: string;
-    /** Pathname component of the request URL. */
-    path: string;
-    /** Timestamp captured at the request boundary. */
-    startedAt: number;
-    /** Request-body value returned by the configured projector, when synchronously available. */
-    requestBody?: RequestBody;
-};
-/** An observed network request and its outcome. */
-type HttpExchange<RequestBody = unknown, ResponseBody = unknown> = {
-    /** Identifier shared with the corresponding {@link HttpRequestStarted}. */
-    requestId: string;
-    /** Network API used for the request. */
-    transport: NetworkTransport;
-    /** Uppercase HTTP method. */
-    method: string;
-    /**
-     * Resolved absolute request input URL, including its query string and
-     * fragment. Redact it before forwarding if either component may be sensitive.
-     */
-    url: string;
-    /** Pathname component of the request URL. */
-    path: string;
-    /** HTTP status code, or `0` when a status is unavailable. */
-    status: number;
-    /** Whether the status code represents a successful response. */
-    ok: boolean;
-    /**
-     * How the request completed. `load` includes successful and non-successful
-     * HTTP responses; inspect `ok` or `status` for HTTP success.
-     */
-    outcome: "load" | "abort" | "timeout" | "error";
-    /** Elapsed request time in milliseconds, when available. */
-    durationMs?: number;
-    /**
-     * Final absolute response URL, when available. This may differ from `url`
-     * after redirects and may contain sensitive query or fragment values.
-     */
-    responseUrl?: string;
-    /** Request-body value returned by the configured projector, when available. */
-    requestBody?: RequestBody;
-    /** Response-body value returned by the configured projector, when available. */
-    responseBody?: ResponseBody;
-};
-/** Metadata supplied to a body projector for one matched exchange. */
-type NetworkBodyProjectionContext<Direction extends NetworkBodyDirection = NetworkBodyDirection> = {
-    /** Whether the observed body belongs to the request or response. */
-    direction: Direction;
-    /** Network API used by the application. */
-    transport: NetworkTransport;
-    /** Uppercase HTTP method. */
-    method: string;
-    /** Resolved absolute request URL. */
-    url: string;
-    /** Pathname component of the request URL. */
-    path: string;
-};
-/**
- * Synchronously selects the only body data that may leave network capture.
- * Textual bodies are supplied as strings; an XHR with `responseType="json"`
- * supplies the browser-parsed value. Returning `undefined`, throwing, or
- * returning a Promise omits the body without affecting the application.
- * `ProjectedBody` describes the exact value delivered to callbacks.
- */
-type NetworkBodyProjector<ProjectedBody = unknown, Direction extends NetworkBodyDirection = NetworkBodyDirection> = (body: unknown, context: NetworkBodyProjectionContext<Direction>) => ProjectedBody | undefined;
-/**
- * Options for {@link captureNetwork}. Request and response body types are
- * inferred from their projectors and propagated to the corresponding callbacks.
- */
-type NetworkCaptureOptions<RequestBody = unknown, ResponseBody = unknown> = {
-    /**
-     * Selects requests to observe. The URL is resolved against the document base
-     * URL and the method is uppercase. Return `true` to observe the request.
-     * This callback must return synchronously; Promise results are not matched.
-     */
-    match: (url: URL, method: string) => boolean;
-    /** Receives completed network exchanges. Return values are not awaited. */
-    onExchange: (exchange: HttpExchange<NoInfer<RequestBody>, NoInfer<ResponseBody>>) => void;
-    /**
-     * Receives matched requests after the platform call succeeds. The request ID
-     * matches the eventual exchange. Return values are not awaited.
-     */
-    onRequest?: (request: HttpRequestStarted<NoInfer<RequestBody>>) => void;
-    /**
-     * Network APIs to observe. Defaults to both `xhr` and `fetch`. Unavailable
-     * transports are skipped if at least one requested transport can be observed.
-     */
-    transports?: readonly NetworkTransport[];
-    /**
-     * Best-effort body observation, enabled independently per direction by a
-     * mandatory projector. Without a projector, that direction is never read.
-     * Autocapture performs no generic parsing or redaction: the projector owns
-     * data minimization and its return value is the only body data reported.
-     */
-    bodyCapture?: {
-        /** Projects a request body. */
-        request?: NetworkBodyProjector<RequestBody, "request">;
-        /** Projects a response body. */
-        response?: NetworkBodyProjector<ResponseBody, "response">;
-    };
-    /** Optional diagnostic logger. */
-    logger?: Logger;
-};
-/** Mechanism that produced a navigation event. */
-type NavigationSource = "push" | "replace" | "pop" | "hash";
-/** A same-document navigation. */
-type NavigationEvent = {
-    /** Current URL pathname. */
-    path: string;
-    /** Current URL query string, including the leading `?` when present. May contain sensitive data. */
-    search: string;
-    /** Current URL fragment, including the leading `#` when present. May contain sensitive data. */
-    hash: string;
-    /** Mechanism that produced the event. */
-    source: NavigationSource;
-};
-/** Options for {@link captureNavigation}. */
-type NavigationCaptureOptions = {
-    /** Receives same-document navigation events. Return values are not awaited. */
-    onNavigate: (event: NavigationEvent) => void;
-    /** Optional diagnostic logger. */
-    logger?: Logger;
-};
-
 /**
  * Observes WebAuthn ceremonies initiated through
  * `navigator.credentials.get()` and `navigator.credentials.create()`.
@@ -259,7 +16,8 @@ type NavigationCaptureOptions = {
  * current environment — the API is missing, a capture is already active, or
  * another integration holds the credential methods in a form that cannot be
  * shared — nothing is modified and the returned handle reports
- * `mode: "unavailable"`.
+ * `mode: "unavailable"`. {@link captureFederatedIdentity} shares the same
+ * attachment; either capture can run and stop independently.
  *
  * Assumptions and limitations:
  *
@@ -281,6 +39,28 @@ type NavigationCaptureOptions = {
  */
 declare function captureWebAuthn(options: WebAuthnCaptureOptions): WebAuthnCaptureHandle;
 
+/**
+ * Observes FedCM requests made through `navigator.credentials.get({ identity })`, such as Google
+ * One Tap on Chromium.
+ *
+ * Each request emits a `started` event followed by a correlated `completed` (an account was
+ * chosen) or `failed` event. Calls without `identity` options are not reported. Tokens, nonces,
+ * provider parameters and login hints are never read into events. Observation never changes a
+ * request's arguments, result, or error; the request is delegated synchronously before anything is
+ * observed, so user activation reaches the browser unchanged.
+ *
+ * Shares one attachment to `navigator.credentials` with {@link captureWebAuthn}; either capture can
+ * start first and stop independently, and a later one joins at whatever surface the first attached
+ * to. `attach` applies only when this capture attaches first, as in {@link captureWebAuthn}. The
+ * handle reports `mode: "unavailable"` when the credential methods cannot be observed or a federated
+ * identity capture is already active.
+ *
+ * @param options Event callback and optional diagnostic logger.
+ * @returns A handle used to inspect the capture mode or stop event delivery.
+ * @throws TypeError when `onEvent` is not a function.
+ */
+declare function captureFederatedIdentity(options: FederatedIdentityCaptureOptions): FederatedIdentityCaptureHandle;
+
 /**
  * Observes selected requests made through `XMLHttpRequest` and `fetch`.
  *
@@ -377,4 +157,4 @@ declare function isValidationMessageVisible(element: Element | null): boolean;
  */
 declare function captureInputValidation(options: InputValidationCaptureOptions): InputValidationCaptureHandle;
 
-export { type CaptureHandle, type HttpExchange, type HttpRequestStarted, type InputValidationCaptureHandle, type InputValidationCaptureOptions, type InputValidationError, type InputValidationState, type Logger, type NavigationCaptureOptions, type NavigationEvent, type NavigationSource, type NetworkBodyDirection, type NetworkBodyProjectionContext, type NetworkBodyProjector, type NetworkCaptureOptions, type NetworkTransport, VERSION, type WebAuthnAttachSurface, type WebAuthnCaptureHandle, type WebAuthnCaptureOptions, type WebAuthnCeremonyCompletedEvent, type WebAuthnCeremonyContext, type WebAuthnCeremonyEvent, type WebAuthnCeremonyFailedEvent, type WebAuthnCeremonyStartedEvent, type WebAuthnMediation, type WebAuthnUiMode, captureInputValidation, captureNavigation, captureNetwork, captureWebAuthn, composedPath, inputValidationCode, isValidationMessageVisible };
+export { CaptureHandle, FederatedIdentityCaptureHandle, FederatedIdentityCaptureOptions, type InputValidationCaptureHandle, type InputValidationCaptureOptions, type InputValidationError, type InputValidationState, NavigationCaptureOptions, NetworkCaptureOptions, VERSION, WebAuthnCaptureHandle, WebAuthnCaptureOptions, captureFederatedIdentity, captureInputValidation, captureNavigation, captureNetwork, captureWebAuthn, composedPath, inputValidationCode, isValidationMessageVisible };