@buoy-gg/bug-links 0.0.0-stage → 7.0.81

package/lib/typescript/engine/otherTabs.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The app's other browser tabs, for the loader.
+ *
+ * Every tab of a web app shares its storage, so a case loaded in one tab
+ * changes the data of all of them. Rounds 9 to 12 of the review found one race
+ * after another between tabs. A message-and-wait tab check couldn't prove a
+ * frozen or slow tab wasn't there, and each tab's own queue only ordered its
+ * own steps. So bug links uses the browser's Web Locks API, which every tab
+ * of an origin shares:
+ *
+ * - Each top-level tab holds a shared "tab" lock for its whole life, so
+ *   `navigator.locks.query()` counts the app's tabs. A frame doesn't take
+ *   one. Safari drops a page's locks when it goes into the back cache, so a
+ *   page that comes back from there reloads (index.tsx).
+ * - Every step that changes a case (load, Restore, End, Use live requests,
+ *   a late state pass) runs under one exclusive "step" lock, across all tabs.
+ *
+ * A browser without Web Locks can't do either, so a load there is refused.
+ * React Native has one app: never other tabs, and no lock needed.
+ */
+type LockManagerLike = {
+    request<T>(name: string, options: {
+        mode: "shared" | "exclusive";
+    }, callback: () => Promise<T> | T): Promise<T>;
+    query(): Promise<{
+        held?: {
+            name?: string;
+            clientId?: string;
+        }[];
+    }>;
+};
+/** Whether this runtime is a browser page (tests count as one when they pass locks). */
+export declare function tabsMatter(): boolean;
+/** Take this tab's lock for its whole life. Called at boot, so a tab is counted before it does anything. */
+export declare function listenForOtherTabs(): Promise<void>;
+/** Why a load can't run here because of the app's other tabs, or null. Off the web, always null. */
+export declare function tabsProblem(): Promise<string | null>;
+/**
+ * Run a step under the lock every tab shares, so no two tabs change a case
+ * at once. Off the web, it just runs; a browser with no Web Locks refuses.
+ */
+export declare function withStepLock<T>(work: () => Promise<T>): Promise<T>;
+/**
+ * Run under an exclusive lock with this name, shared by every tab. Off the
+ * web, it just runs. A browser with no Web Locks can't keep two tabs from
+ * saving over each other, so shared changes are refused there.
+ */
+export declare function withTabLock<T>(name: string, work: () => Promise<T>): Promise<T>;
+/** Tests: use this lock manager (null for none), and act as a frame or not. */
+export declare function setTabLocksForTests(locks: LockManagerLike | null, frame?: boolean): void;
+export {};
+//# sourceMappingURL=otherTabs.d.ts.map

package/lib/typescript/engine/phoneCheck.d.ts

@@ -0,0 +1,8 @@
+import { type BugCase } from "@buoy-gg/shared-ui";
+export type PhoneFacts = BugCase["app"];
+/** Each difference as a short sentence, most likely to matter first. Empty when they match. */
+export declare function phoneDifferences(theirs: PhoneFacts | undefined, mine: PhoneFacts): string[];
+export declare function otherAppReason(theirs: PhoneFacts | undefined, mine: PhoneFacts): string | null;
+/** This phone and app, the way a case writes them (capture.ts). */
+export declare function thisPhone(): PhoneFacts;
+//# sourceMappingURL=phoneCheck.d.ts.map

package/lib/typescript/engine/phoneCrypto.d.ts

@@ -0,0 +1,16 @@
+import { type BugCaseCrypto, type TeamKeyCrypto } from "@buoy-gg/shared-ui";
+export declare function phoneCaseCrypto(): BugCaseCrypto;
+/** WebCrypto when the runtime has it, else the plain JS lock. */
+export declare function caseCrypto(): BugCaseCrypto;
+/**
+ * Team keys on a phone: P-256 from @noble/curves, SHA-256 and HMAC from
+ * @noble/hashes (both audited, no dependencies), AES-GCM from @noble/ciphers.
+ * Random bytes come from our own source; noble's needs WebCrypto, which
+ * Hermes lacks.
+ */
+export declare function phoneTeamKeyCrypto(): TeamKeyCrypto;
+/** WebCrypto when the runtime has it, else the plain JS one. */
+export declare function teamKeyCrypto(): TeamKeyCrypto;
+/** Unzip, stopping as soon as the output passes `maxBytes` (a zip bomb stops here). */
+export declare function gunzipCapped(data: Uint8Array, maxBytes: number): Uint8Array;
+//# sourceMappingURL=phoneCrypto.d.ts.map

package/lib/typescript/engine/randomBytes.d.ts

@@ -0,0 +1,7 @@
+export type RandomSource = "getRandomValues" | "expo-uuid";
+export declare function randomSource(): RandomSource | null;
+export declare const NO_RANDOM_MESSAGE = "This app has no safe random numbers, so Buoy can't lock a bug case. Add expo-modules-core (any Expo app has it), react-native-get-random-values or react-native-quick-crypto.";
+export declare function randomBytes(length: number): Uint8Array;
+/** Pack the random bits of v4 UUIDs into bytes. Exported for tests. */
+export declare function bytesFromUuids(length: number, nextUuid: () => string): Uint8Array;
+//# sourceMappingURL=randomBytes.d.ts.map

package/lib/typescript/engine/reporter.d.ts

@@ -0,0 +1,53 @@
+import { type BugPriority } from "./client";
+import { type MyBugLink } from "./linksStore";
+export type ReportPhase = "capturing" | "sending" | "sent" | "waiting" | "failed";
+export interface ReportState {
+    localId: string | null;
+    phase: ReportPhase;
+    message: string;
+    url?: string;
+    removed: number;
+    copied?: boolean;
+    /** Why it is waiting or failed, for the right button ("signed_out" -> Sign in). */
+    code?: string;
+}
+export declare function copyWithin(text: string, ms: number): Promise<boolean>;
+export declare function reportState(): ReportState | null;
+export declare function subscribeReportState(listener: () => void): () => void;
+export declare function dismissReportState(): void;
+/**
+ * Capture, lock, save and send a bug case. A second tap while one is going
+ * returns the same report instead of making two.
+ */
+export declare function reportBug(options?: {
+    note?: string;
+    priority?: BugPriority;
+}): Promise<MyBugLink | null>;
+/**
+ * Send one saved case now (or its new note, or its delete). `asMe` sends a
+ * case made by another sign-in as the current one; only a person's tap does.
+ */
+export declare function sendLink(localId: string, options?: {
+    asMe?: boolean;
+}): Promise<MyBugLink | null>;
+/** Try every waiting case now: the app came back, or the person asked. */
+export declare function retryWaiting(): Promise<void>;
+/**
+ * Lock a sent case to the team now: its team key wasn't there or wasn't
+ * trusted when it went up. Only the wrap goes (113 bytes), with the edit
+ * token. Sending the same wrap twice is fine.
+ */
+export declare function wrapLater(localId: string): Promise<MyBugLink | null>;
+/**
+ * The tester changes how soon their bug needs a fix. Not sent yet: the send
+ * takes it. Sent: it goes with the edit token, and waits to go again if the
+ * phone is offline. Leave out `priority` to retry a waiting one.
+ */
+export declare function setLinkPriority(localId: string, priority?: BugPriority): Promise<MyBugLink | null>;
+/** Put a note in a case that was already made. The link stays the same. */
+export declare function addNote(localId: string, note: string): Promise<MyBugLink | null>;
+/** Delete a case here and on the server. Offline, the server copy goes later. */
+export declare function deleteLink(localId: string): Promise<void>;
+/** Tests only. */
+export declare function resetReporterForTests(): void;
+//# sourceMappingURL=reporter.d.ts.map

package/lib/typescript/engine/sandbox.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Turn a case's recorded web calls into Network override rules: the sandbox.
+ *
+ * Loading a bug must not call real servers with a teammate's account, and it
+ * must show the data the reporter saw. So every call the app makes is
+ * answered from the recording, and anything with no recording is blocked and
+ * counted as a miss.
+ *
+ * Rules are a first-match list, so order is the whole design:
+ *
+ *   1. Exact answers. By default each call gets its NEWEST answer, the one
+ *      on screen when the bug was reported: a loaded app makes fewer calls
+ *      than the reporter's whole session did, and replaying that history in
+ *      order would stop part way, on an old answer (found on the Bug Lab).
+ *      With `sequence: true` a call made twice gets both answers in the
+ *      order they came (each but the last retires after one use), for bugs
+ *      in polling or retries. The last one keeps answering, for refetches.
+ *   2. Block everything else, and count it as a miss. A call the reporter
+ *      never made (page 3 of a feed) is never answered with made-up data:
+ *      an earlier "any query" fallback did that on the Bug Zoo, and showed
+ *      page 2 again as if it were page 3.
+ *
+ * A secret the scrubber took out of a URL (`?token=[removed:secret]`) becomes
+ * `*`, so the teammate's own token still matches. So does the value of a
+ * cache-buster (`?_=1729…`, `?t=…`), which is different on every call. Calls that share one URL
+ * are told apart by their input: GraphQL by `operationName` and its
+ * variables, and REST by its JSON body (`POST /search {"q":"pie"}`), but only
+ * when that URL was called with more than one input. The most specific rules
+ * go first, so such a wildcard never answers a longer path.
+ */
+import type { BugCase } from "@buoy-gg/shared-ui";
+export declare const SANDBOX_PREFIX = "Bug case: ";
+export declare const BLOCK_RULE_NAME = "Bug case: blocked (no recorded answer)";
+export interface SandboxRule {
+    name: string;
+    enabled: true;
+    /** Network keeps sandbox rules on without account access, and never auto-pauses them. */
+    sandbox: true;
+    urlPattern: string;
+    methods?: string[];
+    graphqlOperation?: string;
+    /** The GraphQL call's variables (sorted-key JSON), when one operation had several inputs. */
+    graphqlVariables?: string;
+    /** A REST call's JSON body (sorted-key JSON), when one URL had several bodies. */
+    bodyJson?: string;
+    graphqlSingle?: boolean;
+    kind: "respond" | "fail";
+    status?: number;
+    headers?: Record<string, string>;
+    body?: string;
+    failKind?: "network" | "timeout";
+    delayMs?: number;
+    times: number | null;
+}
+export interface SandboxPlan {
+    rules: SandboxRule[];
+    /** Recorded answers among the rules (all but the block rule). */
+    answers: number;
+    /** Calls with no usable recording (body too big, cut for the rule limit). */
+    skipped: {
+        method: string;
+        url: string;
+        reason: string;
+    }[];
+}
+/** A glob that matches the URL literally, with removed secrets and cache-busters as wildcards. */
+export declare function urlGlob(url: string): string;
+/** The GraphQL operation name in a request body, else nothing. */
+export declare function graphqlOperation(requestData: unknown): string | undefined;
+/**
+ * A GraphQL call's variables, for Network's parsed `graphqlVariables` match,
+ * so two calls of one operation with different inputs get their own answers.
+ * Missing variables are {}. None when a value was taken out: the app's real
+ * body has the real value, and it would never match.
+ */
+export declare function graphqlVariablesKey(requestData: unknown): string | undefined;
+export declare function buildSandbox(kase: Pick<BugCase, "network">, options?: {
+    sequence?: boolean;
+}): SandboxPlan;
+export declare function isSandboxRule(rule: {
+    name?: string;
+} | null | undefined): boolean;
+//# sourceMappingURL=sandbox.d.ts.map

package/lib/typescript/engine/settings.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Bug links settings: where cases go, and the app's own scrub rules.
+ *
+ * Order of strength: what a person set in the tool (saved on the phone), then
+ * what the app passed to `configureBugLinks`, then the default (buoy.gg). The
+ * person wins so a dev can point a build at a local server without a rebuild.
+ */
+import { type ScrubRules } from "@buoy-gg/shared-ui";
+import { type BugLinksMediaConfig } from "../media/frames";
+export declare const DEFAULT_SERVER = "https://buoy.gg";
+export interface BugLinksConfig {
+    /** Server origin, like "https://buoy.gg". */
+    server?: string;
+    /** Extra fields to hide, and fields to keep, on top of Buoy's scrubber. */
+    rules?: ScrubRules;
+    /**
+     * The team key root(s) this app trusts, from the team list's admin page
+     * (one id, or several while a team moves to a new root). With none, the
+     * phone trusts the first root it sees. EXPO_PUBLIC_BUOY_TEAM_KEY works too.
+     */
+    teamKey?: string | string[];
+    /** Pictures and video (SPEC.md S1). On by default, with every mask on. */
+    media?: BugLinksMediaConfig;
+}
+export declare function bugLinksSettingsRead(): boolean;
+/**
+ * A server must be https. Plain http is allowed only for this Mac or the local
+ * network, where a dev runs the bug links dev server.
+ */
+export declare function checkServer(url: string): string | null;
+export declare function configureBugLinks(config: BugLinksConfig): void;
+export declare function loadBugLinksSettings(): Promise<void>;
+export declare function bugLinksServer(): string;
+export declare function bugLinksRules(): ScrubRules | undefined;
+/** The pinned key roots, or null when the app pins none. An empty list (only bad pins) pins nothing. */
+export declare function teamKeyPins(): string[] | null;
+/** Set (or with null, clear) the server a person picked. */
+export declare function setBugLinksServer(url: string | null): Promise<string>;
+export declare function subscribeBugLinksSettings(listener: () => void): () => void;
+/** Tests only. */
+export declare function resetBugLinksSettingsForTests(): void;
+//# sourceMappingURL=settings.d.ts.map

package/lib/typescript/engine/tabStorage.d.ts

@@ -0,0 +1,6 @@
+export declare const tabStorage: {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+};
+//# sourceMappingURL=tabStorage.d.ts.map

package/lib/typescript/engine/teamKeys.d.ts

@@ -0,0 +1,37 @@
+export interface TeamKeyTarget {
+    owner: string;
+    teamKeyId: string;
+    keyVersion: number;
+    pub: Uint8Array;
+}
+export type TeamKeyPick = {
+    kind: "ok";
+    target: TeamKeyTarget;
+}
+/**
+ * The team list isn't on (or this server has no team keys): nothing to
+ * wrap, nothing to wait for. `owner` is the team (or account) the server
+ * says this sign-in sends for, when it said.
+ */
+ | {
+    kind: "off";
+    owner?: string;
+}
+/** Wrap later. `owner` as for "off", when the server said. */
+ | {
+    kind: "wait";
+    code: TeamKeyWaitCode;
+    message: string;
+    teamKeyId?: string;
+    owner?: string;
+};
+export type TeamKeyWaitCode = "offline" | "signed_out" | "no_current" | "pin" | "new_root" | "untrusted";
+/** The key to wrap to now, or why not. Cached for a few minutes per server and sign-in. */
+export declare function pickTeamKey(server: string, credential: string | null, options?: {
+    fresh?: boolean;
+}): Promise<TeamKeyPick>;
+/** A person said yes to a new key root, in the Bug Links screen. */
+export declare function trustTeamRoot(server: string, teamKeyId: string, credential: string | null): Promise<void>;
+/** Tests only. */
+export declare function resetTeamKeysForTests(): void;
+//# sourceMappingURL=teamKeys.d.ts.map

package/lib/typescript/engine/teamList.d.ts

@@ -0,0 +1,63 @@
+import { type BugPriority } from "./client";
+import { type LoadOptions, type LoadReport } from "./loader";
+export type TeamStatus = "new" | "seen" | "fixed" | "wont_fix";
+export type TeamView = "open" | "mine" | "all";
+export interface TeamBug {
+    id: string;
+    title: string;
+    priority: BugPriority;
+    status: TeamStatus;
+    assignee: string | null;
+    /** The assignee's name, or "You". */
+    assigneeName: string | null;
+    /** Who sent it, or "You". */
+    reporter: string;
+    createdAt: string;
+    /** "1.0.0 (12)", from the bug's card. */
+    build: string | null;
+    error: string | null;
+    /** The first report, when this is a repeat. */
+    repeatOf: string | null;
+    /** This phone holds its key and a card that checks out: it can be loaded. */
+    canOpen: boolean;
+    rowRevision: number;
+}
+export type TeamBlock = "signed_out" | "no_access" | "needs_pro" | "own_kits" | "no_custody" | "offline" | "error";
+export type TeamListState = {
+    kind: "idle";
+} | {
+    kind: "loading";
+}
+/** `refreshing`: a Refresh is reading the list again. */
+ | {
+    kind: "ready";
+    bugs: TeamBug[];
+    me: string;
+    refreshing: boolean;
+} | {
+    kind: "blocked";
+    code: TeamBlock;
+    message: string;
+};
+/** Who is asking right now: the server and the person, or null when signed out. */
+export declare function whoNow(): string | null;
+/** The list, but only for whoever is signed in now. */
+export declare function teamBugs(): TeamListState;
+export declare function subscribeTeamBugs(listener: () => void): () => void;
+/** Drops the kit, the keys and the list. The screen calls this when it closes. */
+export declare function forgetTeamBugs(): void;
+/** Loading answers web calls from the case, which only a dev build can do. */
+export declare function canLoadTeamBugs(): boolean;
+/** Reads the team list fresh. Never throws: a problem shows as a blocked state. `attempt`: a restart after a team move. */
+export declare function loadTeamBugs(attempt?: number): Promise<void>;
+/** One view of the list. Open and Mine: most urgent first, then newest. Repeats stay out of both. */
+export declare function teamView(bugs: readonly TeamBug[], view: TeamView, me: string): TeamBug[];
+/** Take it, Let go, Fixed or Still broken. Saved, then shown here at once. */
+export declare function changeTeamBug(id: string, change: {
+    status?: TeamStatus;
+    assignee?: string | null;
+}): Promise<void>;
+/** Loads a team bug into this app, with no link: the key came from the team kit. */
+export declare function loadTeamBug(id: string, options?: Omit<LoadOptions, "source">): Promise<LoadReport>;
+export declare function resetTeamBugsForTests(): void;
+//# sourceMappingURL=teamList.d.ts.map

package/lib/typescript/index.d.ts

@@ -0,0 +1,23 @@
+export { reportBugToolPreset, bugLinksToolPreset, createBugLinksTool, BUG_LINKS_COLOR } from "./preset";
+export { bugLinksSyncAdapter, getBugLinksSnapshot } from "./sync/bugLinksSyncAdapter";
+export type { BugLinksSnapshot } from "./sync/bugLinksSyncAdapter";
+export { BugLinksBody } from "./components/BugLinksBody";
+export { BugLinksOverlay } from "./components/overlays";
+export { BuoyMask, BuoyUnmask } from "./media/BuoyMask";
+export { configureMedia, startRecording, stopRecording, markBugHere, probeFrame, mediaUnavailableReason, } from "./media/frames";
+export type { BugLinksMediaConfig } from "./media/frames";
+export { configureBugLinks, setBugLinksServer, bugLinksServer, DEFAULT_SERVER } from "./engine/settings";
+export type { BugLinksConfig } from "./engine/settings";
+export { reportBug, addNote, setLinkPriority, deleteLink, retryWaiting, reportState, subscribeReportState } from "./engine/reporter";
+export { BUG_PRIORITIES, type BugPriority } from "./engine/client";
+export type { ReportState, ReportPhase } from "./engine/reporter";
+export { myLinks, subscribeMyLinks } from "./engine/linksStore";
+export type { MyBugLink, MyBugLinkStatus } from "./engine/linksStore";
+export { loadBugCase, loadAgain, undoBugCase, leaveSandbox, loadedCase, subscribeLoadedCase } from "./engine/loader";
+export type { LoadReport, LoadStep, LoadedCase, LoadOptions } from "./engine/loader";
+export { openBugLink, fetchBugLink } from "./engine/opener";
+export { buildSandbox } from "./engine/sandbox";
+export { phoneCaseCrypto, caseCrypto } from "./engine/phoneCrypto";
+export { randomSource } from "./engine/randomBytes";
+export { setBugLinksCredentialProvider } from "./engine/credential";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/media/BuoyMask.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Markers for what pictures hide (SPEC.md H6 to H8). The native frame taker
+ * finds them by nativeID, so they stay as real views (collapsable={false}).
+ *
+ *   <BuoyMask>    hides this part and all inside it, even with a setting off.
+ *   <BuoyUnmask>  shows this part, even with a setting on. Password fields
+ *                 inside are still hidden, and Mask inside still hides.
+ */
+import type { ReactNode } from "react";
+import { type StyleProp, type ViewStyle } from "react-native";
+interface MarkerProps {
+    children?: ReactNode;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+export declare function BuoyMask({ children, style, testID }: MarkerProps): import("react").JSX.Element;
+export declare function BuoyUnmask({ children, style, testID }: MarkerProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=BuoyMask.d.ts.map

package/lib/typescript/media/frames.d.ts

@@ -0,0 +1,34 @@
+import { type BugCase } from "@buoy-gg/shared-ui";
+export interface BugLinksMediaConfig {
+    /** A frame after each tap (internal mode). Default true. */
+    pictures?: boolean;
+    /** "manual": the tester can record. "always": also keep the last 30 s. "off": no video. */
+    video?: "manual" | "always" | "off";
+    maskAllText?: boolean;
+    maskAllImages?: boolean;
+    maskAllInputs?: boolean;
+    /** "internal" for QA, devs and employees. "customer" for the app's own users: the last frame only. */
+    mode?: "internal" | "customer";
+}
+/** Why there are no frames at all on this build, or null. */
+export declare function mediaUnavailableReason(): string | null;
+/** Turns frames on with the app's settings (S1). Safe to call more than once. */
+export declare function configureMedia(next?: BugLinksMediaConfig): void;
+export declare function mediaConfig(): BugLinksMediaConfig;
+/** Starts frames with the defaults the first time Bug Links is used. */
+export declare function ensureMediaStarted(): void;
+export declare function startRecording(): void;
+export declare function stopRecording(): void;
+export declare function markBugHere(): void;
+/** Lets new frames in again after a case was made (F8 froze them). */
+export declare function resumeMedia(): void;
+/** The mask zoo test hook: one frame now, with its boxes. */
+export declare function probeFrame(): Promise<unknown>;
+/**
+ * Adds the `media` part to a case. Frames are linked to taps by time. Anything
+ * missing goes in `missing` with a reason (C5). Never throws.
+ */
+export declare function addMediaToCase(kase: BugCase): Promise<BugCase>;
+/** Makes the case smaller when it's too big to send: fewer frames, down to none. */
+export declare function shrinkMedia(kase: BugCase, bytes: number): BugCase;
+//# sourceMappingURL=frames.d.ts.map

package/lib/typescript/media/nativeFrames.d.ts

@@ -0,0 +1,2 @@
+export declare function loadFramesModule(): unknown;
+//# sourceMappingURL=nativeFrames.d.ts.map

package/lib/typescript/media/nativeFrames.web.d.ts

@@ -0,0 +1,2 @@
+export declare function loadFramesModule(): unknown;
+//# sourceMappingURL=nativeFrames.web.d.ts.map

package/lib/typescript/media/webFrames.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Pictures in a browser (research/bug-links-2026-10/media/SPEC.md section 3,
+ * "Web"). React Native Web, React DOM, Vue, Angular, Solid and every other
+ * page get the same frame taker, through `nativeFrames.web.ts`.
+ *
+ * A page can't be read back as pixels, so a frame is made from a copy:
+ *
+ * 1. Copy the page (`cloneNode`) in one go, so the copy can't change under us.
+ * 2. Hide the private parts IN THE COPY, before anything is drawn (H1): their
+ *    text is wrapped and filled, their values cleared, their pictures swapped
+ *    for a blank. Buoy's own screens are taken out of the copy (F5).
+ * 3. Draw the copy into a canvas through an SVG `<foreignObject>`, then fill
+ *    each hidden part's box again from where it sat on the live page (H10).
+ * 4. JPEG, 1x, quality 0.6 (F1).
+ *
+ * Because the copy itself is hidden before it is drawn, a part that lands in
+ * the wrong place (a scroll the copy can't show, a font that didn't load) is
+ * still hidden. Anything in doubt drops the frame and keeps a reason (H2).
+ */
+export interface WebMaskSettings {
+    text: boolean;
+    images: boolean;
+    inputs: boolean;
+}
+interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface Part {
+    testID: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface Snapshot {
+    svg: string;
+    w: number;
+    h: number;
+    rects: Box[];
+    parts: Part[];
+    /** Parts hidden (V4). */
+    boxes: number;
+    mainMs: number;
+}
+/** True while a Buoy screen is open (F5). Cheap: run before copying anything. */
+export declare function buoyScreenOpen(vw?: number, vh?: number): boolean;
+/**
+ * Copies the page and hides what's private in the copy. Throws FrameError
+ * with a reason when the copy can't be trusted.
+ */
+export declare function snapshotPage(settings: WebMaskSettings, withParts?: boolean): Snapshot & {
+    buoyOpen: boolean;
+};
+export interface WebFramesOptions {
+    pictures?: boolean;
+    video?: "manual" | "always" | "off";
+    maskAllText?: boolean;
+    maskAllImages?: boolean;
+    maskAllInputs?: boolean;
+    mode?: "internal" | "customer";
+    videoFps?: number;
+}
+/** The same calls as the native BuoyFrames module, for a browser. */
+export declare class WebFrameEngine {
+    private enabled;
+    private pictures;
+    private customer;
+    private masks;
+    private videoFps;
+    private taps;
+    private video;
+    private last;
+    private marks;
+    private dropped;
+    private frozen;
+    private busy;
+    private run;
+    private slowInRow;
+    private stoppedReason;
+    private lastReason;
+    private buttonLastT;
+    private downOnBuoy;
+    private tapTimer;
+    private videoTimer;
+    private videoOn;
+    private videoAlways;
+    private videoUntil;
+    private listening;
+    /** The frame being made now, so the last frame can wait for it (F8). */
+    private inflight;
+    /** A last frame waiting for the frame before it to finish (F8). */
+    private pendingLast;
+    /** M1: after a slow frame, tap and video frames wait until this time. */
+    private easeUntil;
+    configure(o?: WebFramesOptions): void;
+    status(): Promise<{
+        available: boolean;
+        enabled: boolean;
+        mode: string;
+        stopped: string | null;
+    }>;
+    private listen;
+    /** A touch on Buoy: take the last frame now, before the dial or the sheet draws (F8). */
+    private onDown;
+    private onUp;
+    startVideo(always: boolean): void;
+    stopVideo(): void;
+    mark(): void;
+    /** F8: the last frame. Buoy is open by now, so the frame from the touch on Buoy wins while it's new. */
+    captureLast(): Promise<{
+        ok: boolean;
+        reason: string | null;
+    }>;
+    takeMedia(): Promise<{
+        frames: {
+            t: number;
+            kind: "last" | "tap" | "video";
+            w: number;
+            h: number;
+            jpeg: string;
+            boxes: number;
+        }[];
+        marks: number[];
+        dropped: number;
+        reasons: {
+            [x: string]: number;
+        };
+        stopped: string | null;
+        lastAgeMs: number | null;
+        settings: {
+            maskAllText: boolean;
+            maskAllImages: boolean;
+            maskAllInputs: boolean;
+        };
+    }>;
+    resume(): void;
+    clear(): void;
+    stopAll(): void;
+    /** Test hook for the mask zoo: one frame now, with its boxes and JPEG. */
+    probe(): Promise<{
+        ok: boolean;
+        reason: string | null;
+        failed: string | null;
+        parts: never[];
+        buoyOpen: boolean;
+        jpeg: null;
+        w: number;
+        h: number;
+    } | {
+        ok: boolean;
+        reason: null;
+        failed: null;
+        parts: Part[];
+        buoyOpen: boolean;
+        jpeg: string;
+        w: number;
+        h: number;
+    } | {
+        ok: boolean;
+        reason: string;
+        failed: null;
+        parts: Part[];
+        buoyOpen: boolean;
+        jpeg: null;
+        w: number;
+        h: number;
+    }>;
+    private drop;
+    private take;
+    private makeFrame;
+    private noteSpeed;
+    private keep;
+}
+export {};
+//# sourceMappingURL=webFrames.d.ts.map