@fixback/expo 0.1.0

package/dist/auto-report-backoff.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Client-side backpressure for **automatic** error reports — a verbatim port of
+ * `packages/sdk/src/auto-report-backoff.ts` (spec 0003 §E/§H). When ingest
+ * sheds `source: auto` load it answers `429` with a `Retry-After`; the SDK
+ * honours it by holding a pause window during which further `source: auto`
+ * reports are dropped without touching the network. **Manual** reports — a
+ * human tapping Send — never consult this gate.
+ */
+/** A source of the current time in epoch milliseconds — injectable for tests. */
+export type Clock = () => number;
+/** The hold window applied when a `429` carries no usable `Retry-After`. */
+export declare const DEFAULT_RETRY_AFTER_SECONDS = 60;
+/**
+ * Parse a `Retry-After` header into whole seconds to hold for. Handles both
+ * HTTP forms — a delta-seconds integer and an HTTP-date (measured from `now`,
+ * rounded up and clamped at zero) — and falls back to
+ * {@link DEFAULT_RETRY_AFTER_SECONDS} when the header is absent, blank, or
+ * unparseable.
+ */
+export declare function parseRetryAfter(header: string | null | undefined, now: number): number;
+/**
+ * A single pause window for `source: auto` reports. `hold` opens (or extends)
+ * it from a `429`'s `Retry-After`; `isPaused` reports whether it is still open.
+ * The default instance in `submit.ts` is shared across the app's reports so the
+ * hold persists across successive auto submissions.
+ */
+export declare class AutoReportBackoff {
+    private readonly now;
+    /** Epoch ms until which `source: auto` reports are held; `0` when clear. */
+    private pausedUntil;
+    constructor(now?: Clock);
+    /** Is the `source: auto` pause window currently open? */
+    isPaused(): boolean;
+    /** Whole seconds remaining in the pause window (`0` when clear). */
+    retryAfterSeconds(): number;
+    /**
+     * Open (or extend) the window from a `429`'s `Retry-After` value, returning
+     * the seconds it will hold for. The window only ever grows — a shorter later
+     * hold never clips a longer one already in effect.
+     */
+    hold(retryAfterHeader: string | null | undefined): number;
+}

package/dist/auto-report-backoff.js

@@ -0,0 +1,67 @@
+/**
+ * Client-side backpressure for **automatic** error reports — a verbatim port of
+ * `packages/sdk/src/auto-report-backoff.ts` (spec 0003 §E/§H). When ingest
+ * sheds `source: auto` load it answers `429` with a `Retry-After`; the SDK
+ * honours it by holding a pause window during which further `source: auto`
+ * reports are dropped without touching the network. **Manual** reports — a
+ * human tapping Send — never consult this gate.
+ */
+/** The hold window applied when a `429` carries no usable `Retry-After`. */
+export const DEFAULT_RETRY_AFTER_SECONDS = 60;
+/**
+ * Parse a `Retry-After` header into whole seconds to hold for. Handles both
+ * HTTP forms — a delta-seconds integer and an HTTP-date (measured from `now`,
+ * rounded up and clamped at zero) — and falls back to
+ * {@link DEFAULT_RETRY_AFTER_SECONDS} when the header is absent, blank, or
+ * unparseable.
+ */
+export function parseRetryAfter(header, now) {
+    if (header == null)
+        return DEFAULT_RETRY_AFTER_SECONDS;
+    const value = header.trim();
+    if (value === "")
+        return DEFAULT_RETRY_AFTER_SECONDS;
+    if (/^\d+$/.test(value)) {
+        return Number(value);
+    }
+    const when = Date.parse(value);
+    if (!Number.isNaN(when)) {
+        return Math.max(0, Math.ceil((when - now) / 1000));
+    }
+    return DEFAULT_RETRY_AFTER_SECONDS;
+}
+/**
+ * A single pause window for `source: auto` reports. `hold` opens (or extends)
+ * it from a `429`'s `Retry-After`; `isPaused` reports whether it is still open.
+ * The default instance in `submit.ts` is shared across the app's reports so the
+ * hold persists across successive auto submissions.
+ */
+export class AutoReportBackoff {
+    now;
+    /** Epoch ms until which `source: auto` reports are held; `0` when clear. */
+    pausedUntil = 0;
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    /** Is the `source: auto` pause window currently open? */
+    isPaused() {
+        return this.now() < this.pausedUntil;
+    }
+    /** Whole seconds remaining in the pause window (`0` when clear). */
+    retryAfterSeconds() {
+        return Math.max(0, Math.ceil((this.pausedUntil - this.now()) / 1000));
+    }
+    /**
+     * Open (or extend) the window from a `429`'s `Retry-After` value, returning
+     * the seconds it will hold for. The window only ever grows — a shorter later
+     * hold never clips a longer one already in effect.
+     */
+    hold(retryAfterHeader) {
+        const now = this.now();
+        const seconds = parseRetryAfter(retryAfterHeader, now);
+        const until = now + seconds * 1000;
+        if (until > this.pausedUntil)
+            this.pausedUntil = until;
+        return seconds;
+    }
+}

package/dist/boot.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The ingest **boot** wire-contract, vendored — kept file-parallel with
+ * `packages/sdk/src/boot.ts` (ADR-0021: a server contract change must be
+ * mirrored in both clients).
+ *
+ * The one mobile difference: a native HTTP stack attaches no `Origin` header,
+ * so the SDK sends the configured `origin` explicitly — the server reads it to
+ * decide `originAllowed` exactly as it does for a browser request (spec 0004 §A).
+ */
+import { type FetchLike } from "./http";
+/** A Project's Gate — who may submit. Mirrors the server's `ProjectGate`. */
+export type ProjectGate = "open" | "invited" | "internal";
+/** The trust tier a Reporter holds. Mirrors the server's `ReporterTier`. */
+export type ReporterTier = "public" | "invited" | "internal";
+/**
+ * Optional identity evidence the SDK forwards to boot. None of it is a tier: the
+ * server re-derives trust from this evidence and never honours a self-declared
+ * tier, so the SDK does not send one.
+ */
+export interface IdentityInputs {
+    readonly signedIdentity?: string;
+    readonly reporterId?: string;
+    readonly anonymousId?: string;
+}
+/** The JSON body `POST /api/ingest/boot` accepts. */
+export interface BootRequest extends IdentityInputs {
+    readonly key: string;
+}
+/**
+ * The Project's effective console/network capture config, served on the boot
+ * answer. Optional on the wire: an older server that does not send it (or a
+ * malformed value) is treated as **capture on**, and init options override
+ * whatever is served.
+ */
+export interface CaptureConfig {
+    readonly console: boolean;
+    readonly network: boolean;
+}
+/**
+ * The boot answer: whether this origin is allowlisted, the Project's Gate, the
+ * caller's derived tier (`null` when a presented identity was refused), whether
+ * a submission would be accepted right now, and the Project's capture config.
+ * The shake gesture arms only when `canSubmit` is true.
+ */
+export interface BootAnswer {
+    readonly originAllowed: boolean;
+    readonly gate: ProjectGate;
+    readonly tier: ReporterTier | null;
+    readonly canSubmit: boolean;
+    /** The Project's console/network capture config; absent ⇒ default-on. */
+    readonly capture?: CaptureConfig;
+}
+/** Join an API base URL with the boot path, tolerating a trailing slash. */
+export declare function bootEndpoint(apiUrl: string): string;
+/**
+ * Ask ingest whether a submission would be accepted for this key / origin /
+ * Gate. Resolves to the boot answer, or `null` when Fixback could not be
+ * reached, the key was refused, or the response was not a boot answer. It never
+ * throws: any non-answer is treated by the caller as "stay dormant", so a
+ * Fixback outage stays invisible to the host app.
+ *
+ * Unlike a browser, React Native attaches no `Origin` header of its own — the
+ * configured origin is sent explicitly so the server's allowlist check works.
+ */
+export declare function requestBoot(apiUrl: string, request: BootRequest, origin: string, fetchImpl?: FetchLike): Promise<BootAnswer | null>;

package/dist/boot.js

@@ -0,0 +1,60 @@
+/**
+ * The ingest **boot** wire-contract, vendored — kept file-parallel with
+ * `packages/sdk/src/boot.ts` (ADR-0021: a server contract change must be
+ * mirrored in both clients).
+ *
+ * The one mobile difference: a native HTTP stack attaches no `Origin` header,
+ * so the SDK sends the configured `origin` explicitly — the server reads it to
+ * decide `originAllowed` exactly as it does for a browser request (spec 0004 §A).
+ */
+import { globalFetch } from "./http";
+/** Join an API base URL with the boot path, tolerating a trailing slash. */
+export function bootEndpoint(apiUrl) {
+    return `${apiUrl.replace(/\/+$/, "")}/api/ingest/boot`;
+}
+/** Narrow an unknown JSON body to a `BootAnswer` before the SDK trusts it. */
+function isBootAnswer(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    return (typeof v.originAllowed === "boolean" &&
+        typeof v.canSubmit === "boolean" &&
+        typeof v.gate === "string" &&
+        (v.tier === null || typeof v.tier === "string"));
+}
+/**
+ * Ask ingest whether a submission would be accepted for this key / origin /
+ * Gate. Resolves to the boot answer, or `null` when Fixback could not be
+ * reached, the key was refused, or the response was not a boot answer. It never
+ * throws: any non-answer is treated by the caller as "stay dormant", so a
+ * Fixback outage stays invisible to the host app.
+ *
+ * Unlike a browser, React Native attaches no `Origin` header of its own — the
+ * configured origin is sent explicitly so the server's allowlist check works.
+ */
+export async function requestBoot(apiUrl, request, origin, fetchImpl) {
+    const doFetch = fetchImpl ?? globalFetch();
+    if (!doFetch)
+        return null;
+    let response;
+    try {
+        response = await doFetch(bootEndpoint(apiUrl), {
+            method: "POST",
+            headers: { "content-type": "application/json", origin },
+            body: JSON.stringify(request),
+        });
+    }
+    catch {
+        return null; // network error / Fixback unreachable
+    }
+    if (!response.ok)
+        return null; // 401 unknown key, or any other refusal
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        return null;
+    }
+    return isBootAnswer(body) ? body : null;
+}

package/dist/breadcrumbs.d.ts

@@ -0,0 +1,276 @@
+/**
+ * The trace **breadcrumb ring buffer** and its React Native capture
+ * instrumentation — a port of `packages/sdk/src/breadcrumbs.ts` kept
+ * file-parallel on purpose (ADR-0021): the entry shapes, stream budgets, caps,
+ * and eviction rules are the web SDK's exactly, so the server and dashboard
+ * cannot tell a mobile trace from a web one.
+ *
+ * Mobile mappings (spec 0004 §D): `console` wrapping is unchanged; network
+ * capture patches `XMLHttpRequest` only — React Native's `fetch` is a polyfill
+ * over XHR, so wrapping both would double-record; navigation crumbs come from
+ * the host app's `trackScreen` calls (there is no `history` to patch); the
+ * masked `ui.*` streams have no mobile source yet and simply never occur.
+ *
+ * Everything private is kept out **at the source**: network crumbs carry method
+ * + URL + status metadata only, **never** bodies; URLs are scrubbed as the
+ * crumb is built. The `beforeSend` choke point (`scrub.ts`) is the final gate.
+ * The SDK must never throw into the host app, so every instrumentation hook is
+ * wrapped: a capture failure is swallowed and the original behaviour always runs.
+ */
+/** Console-style severity a `console` crumb records. */
+export type BreadcrumbLevel = "log" | "info" | "warn" | "error" | "assert" | "debug";
+/**
+ * The kind of activity a crumb records. The full web vocabulary is kept for
+ * wire parity — on mobile only `console`, `navigation`, `xhr`, and `error`
+ * are ever produced today.
+ */
+export type BreadcrumbCategory = "console" | "navigation" | "fetch" | "xhr" | "beacon" | "ui.click" | "ui.input" | "error";
+/** Which API issued a captured network request. */
+export type NetworkApi = "fetch" | "xhr" | "beacon";
+/** A network request's failure classification. */
+export type NetworkOutcome = "ok" | "http-4xx" | "http-5xx" | "network-error" | "timeout" | "aborted" | "opaque-cors";
+/**
+ * A crumb's structured detail. Deliberately narrow: there is **no** field for a
+ * request/response body or an input value, so those can never be recorded.
+ */
+export interface BreadcrumbData {
+    readonly url?: string;
+    readonly method?: string;
+    readonly status?: number;
+    /** A masked target for a `ui.*` crumb — unused on mobile, kept for parity. */
+    readonly target?: string;
+    readonly from?: string;
+    readonly to?: string;
+    readonly errorType?: string;
+}
+/** The type tag on a structured console argument. */
+export type ConsoleArgType = "string" | "number" | "bool" | "null" | "json" | "error";
+/** One structured console argument: a type tag plus a JSON-safe value. */
+export interface ConsoleArg {
+    readonly t: ConsoleArgType;
+    readonly v: unknown;
+}
+/** A `file:line` source location — where a console call was made. */
+export interface SourceLocation {
+    readonly file: string;
+    readonly line: number;
+}
+/**
+ * One entry in a trace stream. Alongside its semantic fields every entry
+ * carries a stable {@link id} and a high-res monotonic {@link mono} timestamp —
+ * both stamped by the buffer on `add` — so entries from the three independent
+ * streams order and cross-link exactly. `timestamp` stays epoch ms.
+ */
+export interface Breadcrumb {
+    readonly category: BreadcrumbCategory;
+    readonly message?: string;
+    readonly level?: BreadcrumbLevel;
+    /** Epoch milliseconds when the crumb was recorded. */
+    readonly timestamp: number;
+    /** A stable id, unique within the buffer — assigned on `add` when not set. */
+    readonly id?: string;
+    /** A high-res monotonic timestamp — assigned on `add`. */
+    readonly mono?: number;
+    readonly data?: BreadcrumbData;
+    /** For a `console` crumb: the call's structured, type-tagged arguments. */
+    readonly args?: readonly ConsoleArg[];
+    /** For a `console` crumb: the best-effort `file:line` the call was made from. */
+    readonly source?: SourceLocation;
+    /** For an auto-captured `error` crumb: ids of the entries preceding the throw. */
+    readonly causedBy?: readonly string[];
+    /** Network crumb metadata, lifted to the top level — never a body or header. */
+    readonly api?: NetworkApi;
+    readonly method?: string;
+    readonly url?: string;
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly durationMs?: number;
+    readonly reqSize?: number;
+    readonly respSize?: number;
+    readonly contentType?: string;
+    readonly outcome?: NetworkOutcome;
+}
+/**
+ * The three independent trace streams. Each is its own FIFO ring with its own
+ * size budget, so a chatty stream can't evict another's lead-up.
+ */
+export type TraceStream = "network" | "console" | "breadcrumbs";
+/** Per-stream ring budgets — the web SDK's numbers, unchanged. */
+export declare const DEFAULT_STREAM_BUDGETS: Readonly<Record<TraceStream, number>>;
+/** The shared age cap: entries older than this are pruned from every stream. */
+export declare const DEFAULT_MAX_AGE_MS: number;
+/** Console levels captured by default: **all** of them. */
+export declare const DEFAULT_CONSOLE_LEVELS: readonly BreadcrumbLevel[];
+/**
+ * The console levels **pinned** against eviction: when the console stream
+ * overflows, `warn`/`error`/`assert` are retained ahead of `log`/`info`/`debug`.
+ */
+export declare const PINNED_CONSOLE_LEVELS: readonly BreadcrumbLevel[];
+/**
+ * The console levels for which `source` (`file:line`) is captured — reading a
+ * call site constructs a `new Error()` on every call, so only the levels that
+ * matter for debugging pay that cost. Mirrors {@link PINNED_CONSOLE_LEVELS}.
+ */
+export declare const SOURCE_CAPTURE_LEVELS: readonly BreadcrumbLevel[];
+/** Which stream a crumb's category belongs to. */
+export declare function streamOf(category: string): TraceStream;
+/** Filters or edits each crumb before it enters the buffer; `null` drops it. */
+export type BeforeBreadcrumb = (crumb: Breadcrumb) => Breadcrumb | null;
+/** Configuration for {@link createBreadcrumbBuffer}. All values are optional. */
+export interface BreadcrumbBufferConfig {
+    /** Per-stream size budgets; any stream omitted falls back to the defaults. */
+    readonly budgets?: Partial<Record<TraceStream, number>>;
+    /** Shared age cap in ms; `0` (or non-positive) disables age pruning. */
+    readonly maxAgeMs?: number;
+    /** A per-crumb filter (mute a category, edit, or drop by returning `null`). */
+    readonly beforeBreadcrumb?: BeforeBreadcrumb | null;
+    /** Epoch clock source, injectable for tests. Defaults to `Date.now`. */
+    readonly now?: () => number;
+    /** High-res monotonic clock, injectable for tests. */
+    readonly mono?: () => number;
+    /** Stable id generator, injectable for tests. */
+    readonly nextId?: () => string;
+}
+/** A live trace buffer. */
+export interface BreadcrumbBuffer {
+    /** Record a crumb (subject to filtering, stamping, size, and age trimming). */
+    add(crumb: Breadcrumb): void;
+    /** The current crumbs, merged across streams and ordered in time. */
+    snapshot(): Breadcrumb[];
+    /** Drop every crumb. */
+    clear(): void;
+}
+/**
+ * Create the per-stream trace buffer: **three independent FIFO rings** —
+ * `network`, `console`, `breadcrumbs` — each trimmed to its own budget so a
+ * chatty stream never evicts another's lead-up, plus a shared age cap.
+ * `snapshot` merges the three streams into one `mono`-ordered array for
+ * transport — the wire keeps its single `trace` field.
+ */
+export declare function createBreadcrumbBuffer(config?: BreadcrumbBufferConfig): BreadcrumbBuffer;
+/** Longest scrubbed URL kept on a crumb. */
+export declare const MAX_URL_LENGTH = 2048;
+/** Structured console argument caps, all applied at assembly. */
+export declare const MAX_ARG_DEPTH = 4;
+export declare const MAX_ARG_ITEMS = 100;
+export declare const MAX_ARG_STRING_LENGTH = 1024;
+export declare const MAX_CONSOLE_ARGS_BYTES = 4096;
+/** Classify one console argument into a type-tagged {@link ConsoleArg}. */
+export declare function toConsoleArg(value: unknown): ConsoleArg;
+/**
+ * A `console` crumb from a captured call's level and arguments. The `message`
+ * is the one-line preview; `args` preserves each argument as a structured,
+ * type-tagged, size-capped value; `source` is the best-effort `file:line`.
+ */
+export declare function consoleCrumb(level: BreadcrumbLevel, args: readonly unknown[], timestamp: number, source?: SourceLocation): Breadcrumb;
+/**
+ * A `navigation` crumb; both sides are scrubbed and length-capped as the crumb
+ * is built. On mobile this is fed by `trackScreen` (spec 0004 §D) — the values
+ * are screen URLs derived from the configured origin.
+ */
+export declare function navigationCrumb(from: string, to: string, timestamp: number): Breadcrumb;
+/** Classify an HTTP status into a {@link NetworkOutcome}. */
+export declare function outcomeFromStatus(status: number | undefined): NetworkOutcome;
+/**
+ * The trivially-known byte size of a request body — a string's UTF-8 length, a
+ * `Blob`'s `.size`, or an `ArrayBuffer`/typed-array `.byteLength`. Anything
+ * that would require **reading** the body returns `undefined`.
+ */
+export declare function trivialBodySize(body: unknown): number | undefined;
+/** Parse a `content-length` header into a non-negative byte count, or `undefined`. */
+export declare function parseContentLength(value: string | null | undefined): number | undefined;
+/** The media type from a `content-type` header (before any `;` parameters). */
+export declare function contentTypeOf(value: string | null | undefined): string | undefined;
+/** The rich metadata a network crumb records — never a body or header. */
+export interface NetworkCrumbInput {
+    readonly api: NetworkApi;
+    readonly method: string;
+    /** The raw request URL — scrubbed as the crumb is built. */
+    readonly url: string;
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly durationMs?: number;
+    readonly reqSize?: number;
+    readonly respSize?: number;
+    readonly contentType?: string;
+    readonly outcome: NetworkOutcome;
+}
+/**
+ * A network crumb with the rich, metadata-only fields the Network tab renders.
+ * The URL is scrubbed and length-capped at assembly. The shape has **no field
+ * for a request/response body or an arbitrary header**.
+ */
+export declare function networkCrumb(input: NetworkCrumbInput, timestamp: number): Breadcrumb;
+/** A thin `xhr` crumb from method + URL + status (outcome derived from the status). */
+export declare function xhrCrumb(method: string, url: string, status: number | undefined, timestamp: number): Breadcrumb;
+/**
+ * An `error` crumb for the failing exception that ends the trace. When
+ * `causedBy` is given (an auto-captured error), it rides on the crumb as the
+ * causal pointer to the ids of the entries immediately preceding the throw.
+ */
+export declare function errorCrumb(error: unknown, timestamp: number, causedBy?: readonly string[]): Breadcrumb;
+/** Detaches an installed instrumentation, restoring the original behaviour. */
+export type Teardown = () => void;
+type AnyFn = (...args: unknown[]) => unknown;
+/** The `console` surface the wrapper patches — injectable for tests. */
+export type ConsoleLike = Partial<Record<BreadcrumbLevel, AnyFn>>;
+/** React Native's global `console`, when present. */
+export declare function globalConsole(): ConsoleLike | undefined;
+/**
+ * The best-effort `file:line` a console call was made from. Parses the frames
+ * of a stack, skipping `skipFrames` leading (SDK-internal) frames so the
+ * source points at the host code that called `console.*`.
+ */
+export declare function sourceFromStack(stack: string | undefined, skipFrames?: number): SourceLocation | undefined;
+/** Wrap `console` methods so calls at the captured levels become crumbs. */
+export declare function instrumentConsole(buffer: BreadcrumbBuffer, consoleObj: ConsoleLike, levels: readonly BreadcrumbLevel[], now: () => number): Teardown;
+/** The XHR instance surface the network instrumentation touches. */
+export interface XhrInstance {
+    status: number;
+    statusText?: string;
+    open(method: string, url: string | {
+        toString(): string;
+    }, ...rest: unknown[]): void;
+    send(body?: unknown): void;
+    getResponseHeader?(name: string): string | null;
+    addEventListener(type: string, listener: () => void): void;
+    removeEventListener(type: string, listener: () => void): void;
+}
+/** The XHR constructor whose prototype is patched — injectable for tests. */
+export interface XhrConstructor {
+    new (): XhrInstance;
+    prototype: XhrInstance;
+}
+/** React Native's global `XMLHttpRequest`, when present. */
+export declare function globalXhr(): XhrConstructor | undefined;
+/**
+ * Patch `XMLHttpRequest` to record a rich network crumb when a request settles.
+ * On React Native this is the **single** network hook: the built-in `fetch` is
+ * a polyfill over XHR, so its traffic is captured here too (as `xhr` crumbs)
+ * and `fetch` itself is deliberately not wrapped — wrapping both would record
+ * every request twice (spec 0004 §D). The `send` body argument is **never read
+ * for content** — only its trivially-known size.
+ */
+export declare function instrumentXhr(buffer: BreadcrumbBuffer, ctor: XhrConstructor | undefined, ignoreUrl: (url: string) => boolean, now: () => number, mono?: () => number): Teardown;
+/** Options for {@link instrumentBreadcrumbs}. */
+export interface InstrumentOptions {
+    readonly consoleObj?: ConsoleLike | null;
+    readonly xhr?: XhrConstructor | null;
+    readonly consoleLevels?: readonly BreadcrumbLevel[];
+    /** Skip URLs (the SDK's own ingest calls) so they never become crumbs. */
+    readonly ignoreUrl?: (url: string) => boolean;
+    readonly now?: () => number;
+    readonly mono?: () => number;
+    /** Instrument the console stream. Defaults to `true`. */
+    readonly captureConsole?: boolean;
+    /** Instrument the network stream (XHR). Defaults to `true`. */
+    readonly captureNetwork?: boolean;
+}
+/**
+ * Install the React Native capture hooks — the console wrapper and the XHR
+ * patch — and return a single teardown that removes them all. Each hook is
+ * independent and defensive: a failure in one never blocks the other, and none
+ * can throw into the host app. An off stream is never instrumented at all.
+ */
+export declare function instrumentBreadcrumbs(buffer: BreadcrumbBuffer, options?: InstrumentOptions): Teardown;
+export {};