@cross-deck/web 0.7.0 → 1.0.0

package/dist/index.d.ts

@@ -139,6 +139,23 @@ interface CrossdeckOptions {
      * `Crossdeck.setDebugMode(true)` after init.
      */
     debug?: boolean;
+    /**
+     * Respect the browser's Do Not Track signal at init (v0.10.0+).
+     * Default `false`. When `true` AND the user has `navigator.doNotTrack === "1"`,
+     * the SDK boots with analytics / marketing / errors all denied —
+     * locked off even if the developer later calls `Crossdeck.consent({...})`.
+     * Industry has effectively deprecated DNT, but opt-in support is the
+     * polite default for privacy-first apps.
+     */
+    respectDnt?: boolean;
+    /**
+     * Scrub PII-shaped strings (email addresses, card numbers) from
+     * URL paths, event properties, and acquisition referrer before they
+     * leave the SDK. Default `true` — Stripe-grade. Disable only if your
+     * pipeline does its own PII redaction downstream and you need the
+     * raw strings.
+     */
+    scrubPii?: boolean;
 }
 /** Auto-tracking flags. See CrossdeckOptions.autoTrack. */
 interface AutoTrackOptions {
@@ -157,6 +174,25 @@ interface AutoTrackOptions {
      * or data-cd-prop-* for custom property tagging.
      */
     clicks: boolean;
+    /**
+     * Web Vitals capture (v0.9.0+) — emits `webvitals.lcp`, `webvitals.inp`,
+     * `webvitals.cls`, `webvitals.fcp`, `webvitals.ttfb` events using the
+     * browser's `PerformanceObserver`. Defaults to true in browsers,
+     * no-op everywhere else. Disable if you have a separate RUM provider
+     * (DataDog, Sentry Performance) and don't want duplicates.
+     */
+    webVitals: boolean;
+    /**
+     * Error capture (v1.0.0+) — installs window.onerror +
+     * window.onunhandledrejection listeners, wraps fetch + XHR to catch
+     * 5xx + network failures, ships each captured error as a Crossdeck
+     * event (kind: error.unhandled / error.unhandledrejection /
+     * error.handled / error.http / error.message). Errors gate on
+     * `consent.errors`. Rate-limited per-fingerprint so a runaway loop
+     * can't flood the queue; browser-extension noise filtered by
+     * default. Default true in browsers, no-op everywhere else.
+     */
+    errors: boolean;
 }
 /** Minimal interface for any pluggable key-value persistence. */
 interface KeyValueStorage {
@@ -164,10 +200,44 @@ interface KeyValueStorage {
     setItem(key: string, value: string): void;
     removeItem(key: string): void;
 }
-/** Identity hint object passed to identify() — at least one field required. */
+/**
+ * Identity hint + profile traits passed to identify().
+ *
+ * `traits` is a free-form bag of profile data (name, plan, signupDate,
+ * teamRole, etc.) that gets persisted on the Crossdeck customer record
+ * and attached to every subsequent event of the identified user as
+ * `$user.<key>` properties for dashboard filtering.
+ *
+ * Like event properties, traits are validated at the SDK boundary —
+ * functions/symbols/undefined dropped, Date / BigInt / Error coerced,
+ * strings > 1024 chars truncated. Caller's object is never mutated.
+ */
 interface IdentifyOptions {
     /** Optional email to attach to the customer record. */
     email?: string;
+    /**
+     * Optional profile traits. Examples:
+     *   `{ name: "Wes", plan: "pro", signedUpAt: "2026-05-11" }`
+     *
+     * Treated like event properties — values are sanitised at the SDK
+     * boundary so a `{ avatar: <File>, callback: () => {} }` payload
+     * doesn't crash the alias request. Server-side, traits land on
+     * `customers/{cdcust}.traits` (additively — existing fields are
+     * preserved unless the new identify call overrides them).
+     */
+    traits?: Record<string, unknown>;
+}
+/**
+ * Group context — Mixpanel-style. Identifies a customer's membership
+ * in an organisational entity (org, account, team, workspace) so B2B
+ * dashboards can answer "how is account X using my product".
+ *
+ * Attached to every event as `$groups.<type>` until cleared via
+ * `Crossdeck.group(type, null)`. Multiple types can coexist (e.g.
+ * `org` + `team`) — the SDK keeps a map keyed by type.
+ */
+interface GroupTraits {
+    [key: string]: unknown;
 }
 /** Properties payload for track(). Arbitrary key/value, JSON-serialisable, ≤ 8 KB. */
 type EventProperties = Record<string, unknown>;
@@ -184,9 +254,34 @@ interface Diagnostics {
     developerUserId: string | null;
     sdkVersion: string | null;
     baseUrl: string | null;
+    /**
+     * Last `serverTime` value the SDK saw on a /sdk/heartbeat response,
+     * along with the local clock value AT that moment. Lets dashboards
+     * (and the developer, in debug mode) detect a wrong-system-clock
+     * problem before it corrupts a day of analytics. Null until the
+     * first heartbeat completes.
+     */
+    clock: {
+        /** Server's view of "now" from the last heartbeat (epoch ms). */
+        lastServerTime: number | null;
+        /** Client's `Date.now()` taken at the same moment as `lastServerTime`. */
+        lastClientTime: number | null;
+        /**
+         * `lastClientTime - lastServerTime` — positive means the client
+         * clock is AHEAD of the server. Outside ±5 minutes is suspicious
+         * and worth surfacing to the developer.
+         */
+        skewMs: number | null;
+    };
     entitlements: {
         count: number;
         lastUpdated: number;
+        /**
+         * Cumulative count of listener invocations that threw. Swallowed
+         * inside the cache (a buggy consumer must not crash the SDK) but
+         * surfaced here so developers can spot broken subscribers.
+         */
+        listenerErrors: number;
     };
     events: {
         buffered: number;
@@ -194,6 +289,13 @@ interface Diagnostics {
         inFlight: number;
         lastFlushAt: number;
         lastError: string | null;
+        /** Consecutive flush failures since the last success. */
+        consecutiveFailures: number;
+        /**
+         * When the next retry is scheduled (epoch ms), or null if the queue
+         * is idle / healthy.
+         */
+        nextRetryAt: number | null;
     };
 }
 
@@ -239,6 +341,187 @@ interface Diagnostics {
 
 type EntitlementsListener = (entitlements: PublicEntitlement[]) => void;
 
+/**
+ * Consent gating — GDPR / CCPA-grade kill switches.
+ *
+ * Three independent dimensions, each defaulting to "granted" but
+ * runtime-overridable:
+ *
+ *   analytics  — track(), identify(), heartbeat(), session/page auto-
+ *                emissions. Off → events drop silently, no network
+ *                calls fire.
+ *   marketing  — paid-traffic click IDs (gclid/fbclid/etc) and
+ *                acquisition referrer URL. Off → these get scrubbed
+ *                before they ever land in the event bag.
+ *   errors     — error / breadcrumb / Web Vitals capture. Off → no
+ *                webvitals.* events emitted, no error reporting (when
+ *                Phase 3 errors land).
+ *
+ * Why this granularity: real consent banners offer "Analytics",
+ * "Marketing", "Functional" as separate boxes. The SDK has to match.
+ *
+ * Default state: every dimension is granted. The developer must
+ * explicitly call `Crossdeck.consent({ analytics: false })` before
+ * the first event to opt OUT — same convention as Google Tag Manager
+ * Consent Mode. To start in deny mode, call `init(...)` then
+ * immediately `consent({ analytics: false, marketing: false, errors:
+ * false })` before any user activity.
+ *
+ * DNT (Do Not Track) browser header is checked once at init and
+ * applied as an automatic deny across all dimensions when
+ * `respectDnt: true` is set in CrossdeckOptions (default false because
+ * the industry has effectively deprecated DNT — but opt-in support
+ * is the polite default for privacy-first apps).
+ */
+interface ConsentState {
+    analytics: boolean;
+    marketing: boolean;
+    errors: boolean;
+}
+
+/**
+ * Breadcrumb ring buffer — context attached to every error report.
+ *
+ * Sentry / Datadog / Bugsnag all ship the same idea: keep a rolling
+ * record of the last N "things the user did" (page views, clicks,
+ * custom events, network calls, console logs). When an error fires,
+ * attach the buffer so the engineer reading the error can see exactly
+ * how the user got into the broken state. The single most powerful
+ * debugging signal in error monitoring — without breadcrumbs, errors
+ * are stack traces with no story.
+ *
+ * Implementation: a circular buffer with a fixed cap. Old entries are
+ * evicted as new ones arrive. The default cap (50) is enough to cover
+ * ~5 minutes of typical user activity without ballooning the error
+ * payload — Sentry uses 100 by default but the SDK is more aggressive
+ * about size since we ship breadcrumbs over the wire with every error,
+ * not as a separate batch.
+ *
+ * Privacy: breadcrumbs auto-emit from the same auto-tracking sources
+ * as analytics events (page.viewed, element.clicked). Those already
+ * skip password fields, form inputs, and cd-noTrack subtrees. Custom
+ * crumbs added via Crossdeck.addBreadcrumb() pass through the same
+ * property sanitiser as track() events.
+ */
+type BreadcrumbCategory = "navigation" | "ui.click" | "ui.input" | "http" | "console" | "custom" | "info";
+type BreadcrumbLevel = "debug" | "info" | "warning" | "error";
+interface Breadcrumb {
+    /** epoch ms */
+    timestamp: number;
+    category: BreadcrumbCategory;
+    level?: BreadcrumbLevel;
+    /** Short human-readable description. */
+    message?: string;
+    /** Arbitrary key/value context for the crumb. */
+    data?: Record<string, unknown>;
+}
+
+/**
+ * Stack-trace parser — normalises Chrome / Firefox / Safari / Edge
+ * stack strings into a common frame shape.
+ *
+ * Why hand-rolled, not stack-trace-js or error-stack-parser libraries:
+ * those weigh 5–15 KB after minification and we'd be pulling in their
+ * full feature matrix just for the parser. The patterns below cover
+ * the four shapes any modern browser emits, totalling ~80 lines.
+ *
+ * The output frame shape mirrors what Sentry's `mechanism: { type:
+ * 'generic' }` events ship, so future source-map symbolication on the
+ * Crossdeck backend has a stable input to work against.
+ *
+ * Defensive: never throws. An unparseable line becomes a `raw` frame
+ * with just the literal text. Engineers reading errors still get the
+ * raw stack as fallback.
+ */
+interface StackFrame {
+    /** Function name, or "?" if anonymous / unparseable. */
+    function: string;
+    /** Source file URL the frame ran in. Empty when unknown. */
+    filename: string;
+    /** 1-indexed line number, or 0 when unknown. */
+    lineno: number;
+    /** 1-indexed column number, or 0 when unknown. */
+    colno: number;
+    /**
+     * True when the frame is in the app's own code (best-effort:
+     * detected by URL not starting with chrome-extension://, etc.).
+     * Helps the dashboard's "your code vs library code" view.
+     */
+    in_app: boolean;
+    /** Raw line from the stack string for debugging when parse fails. */
+    raw: string;
+}
+
+/**
+ * Error capture — the third Crossdeck USP.
+ *
+ * Catches every error source the browser can hand us and ships them as
+ * Crossdeck events. The pipeline reuses the analytics queue:
+ *   - Same durable persistence (errors survive crashes / hard closes)
+ *   - Same exponential backoff (a flapping server doesn't flood
+ *     errors past the rate limit)
+ *   - Same Idempotency-Key (duplicate batches dedup server-side)
+ *   - Same consent gate (consent.errors)
+ *   - Same PII scrub on properties before they leave
+ *
+ * Error sources captured (each toggleable):
+ *   1. window.onerror — uncaught synchronous errors
+ *   2. window.onunhandledrejection — unhandled promise rejections
+ *   3. fetch() wrap — HTTP errors the app code didn't catch
+ *   4. XMLHttpRequest wrap — same, for legacy XHR consumers
+ *   5. Crossdeck.captureError(err) — manual API for try/catch blocks
+ *   6. Crossdeck.captureMessage(msg) — non-error events you want to
+ *      surface as issues (e.g. "we hit the soft-deprecated path")
+ *
+ * Defensive design rules:
+ *   - The error handler must NEVER throw — if our own code crashes
+ *     while reporting an error, we'd take down the host app's error
+ *     handler too. Every callback is wrapped in try/swallow.
+ *   - Recursion guard: a `_reporting` flag prevents the SDK from
+ *     reporting its own errors recursively forever.
+ *   - Rate limited per-fingerprint: max N reports per second to defend
+ *     against runaway loops (e.g. an error in setInterval).
+ *   - Browser-extension noise is filtered by default — those errors
+ *     aren't the developer's fault and would otherwise drown the
+ *     signal.
+ */
+
+type ErrorLevel = "error" | "warning" | "info";
+interface CapturedError {
+    /** When the error fired (epoch ms). */
+    timestamp: number;
+    /** error.unhandled, error.unhandledrejection, error.handled, error.message, error.http */
+    kind: "error.unhandled" | "error.unhandledrejection" | "error.handled" | "error.message" | "error.http";
+    level: ErrorLevel;
+    message: string;
+    /** The error class name when we have it (TypeError, ReferenceError, etc.) */
+    errorType: string | null;
+    /** Parsed stack frames, empty when unavailable. */
+    frames: StackFrame[];
+    /** Raw stack string for fallback display. */
+    rawStack: string | null;
+    /** Origin URL when available (window.onerror's `source` arg). */
+    filename: string | null;
+    lineno: number | null;
+    colno: number | null;
+    /** djb2 hash of message + top frames — group identical errors. */
+    fingerprint: string;
+    /** Snapshot of the breadcrumb buffer at the moment the error fired. */
+    breadcrumbs: Breadcrumb[];
+    /** Free-form context attached via Crossdeck.setContext(). */
+    context: Record<string, unknown>;
+    /** Free-form tags attached via Crossdeck.setTag(). */
+    tags: Record<string, string>;
+    /** "TypeError: x is not a function" → "TypeError" + "x is not a function". */
+    /** Whether the error happened during a fetch / XHR. */
+    http?: {
+        url: string;
+        method: string;
+        status: number;
+        statusText?: string;
+    };
+}
+
 /**
  * Public API surface for @cross-deck/web.
  *
@@ -294,8 +577,145 @@ declare class CrossdeckClient {
     /**
      * Link the anonymous device to a developer-supplied user ID. Cache
      * the resolved Crossdeck customer for follow-up calls.
+     *
+     * v0.9.0+ accepts an optional `traits` bag — profile data (name,
+     * plan, signupDate, role) persisted on the Crossdeck customer record
+     * and queryable from dashboards. Traits are sanitised through the
+     * same validator that gates `track()` properties, so a `{ avatar:
+     * <File>, onSave: () => {} }` payload can't corrupt the alias call.
+     *
+     *   Crossdeck.identify("user_847", {
+     *     email: "wes@pinet.co.za",
+     *     traits: { name: "Wes", plan: "pro", signedUpAt: "2026-05-11" },
+     *   });
+     */
+    identify(userId: string, options?: IdentifyOptions): Promise<AliasResult>;
+    /**
+     * Register super-properties — Mixpanel pattern. Once set, every
+     * subsequent event of THIS SDK instance carries these keys on its
+     * properties bag automatically.
+     *
+     *   Crossdeck.register({ plan: "pro", releaseChannel: "beta" });
+     *   Crossdeck.track("paywall_shown");  // includes plan + releaseChannel
+     *
+     * Values that are `null` are deleted (the explicit "stop tracking
+     * this key" idiom). Returns the resulting bag.
+     *
+     * Sanitised through `validateEventProperties` so a `{ avatar: File }`
+     * payload can't poison the queue at flush time.
+     */
+    register(properties: Record<string, unknown>): Record<string, unknown>;
+    /** Remove a single super-property key. Idempotent. */
+    unregister(key: string): void;
+    /** Snapshot of the current super-property bag. */
+    getSuperProperties(): Record<string, unknown>;
+    /**
+     * Associate the current user with a group (org, team, account, etc.).
+     * Mixpanel / Segment "Group Analytics" pattern.
+     *
+     *   Crossdeck.group("org", "acme_inc");
+     *   Crossdeck.group("team", "design", { headcount: 12 });
+     *
+     * Once set, every subsequent event carries `$groups.<type>: id` on
+     * its properties bag, enabling B2B dashboards ("how is Acme using
+     * the product"). Pass `id: null` to clear a group membership.
+     */
+    group(type: string, id: string | null, traits?: GroupTraits): void;
+    /** Snapshot of the current groups map keyed by type. */
+    getGroups(): Record<string, {
+        id: string;
+        traits?: Record<string, unknown>;
+    }>;
+    /**
+     * Update consent state. Three independent dimensions:
+     *
+     *   analytics  — track() + identify() + auto-emissions
+     *   marketing  — paid-traffic click IDs + referrer URL on events
+     *   errors     — Web Vitals + (future) error reporting
+     *
+     * Each defaults to `true` (granted). Pass partial state — only the
+     * keys you provide are changed.
+     *
+     *   Crossdeck.consent({ analytics: false });
+     *   Crossdeck.consent({ marketing: true, errors: true });
+     *
+     * DNT-derived denies cannot be flipped back on; if the browser said
+     * "don't track" we don't track even if the developer code disagrees.
+     */
+    consent(state: Partial<ConsentState>): ConsentState;
+    /** Snapshot of the current consent state. */
+    consentStatus(): ConsentState;
+    /**
+     * Manually capture an error from a try/catch block.
+     *
+     *   try { …risky… } catch (err) {
+     *     Crossdeck.captureError(err, { context: { plan: "pro" } });
+     *   }
+     *
+     * The error is shipped through the same event queue as analytics
+     * (durable, retried, rate-limited per fingerprint). Sends are gated
+     * by `consent.errors`. Returns silently — never throws, even if the
+     * SDK isn't initialised yet.
      */
-    identify(userId: string, _options?: IdentifyOptions): Promise<AliasResult>;
+    captureError(error: unknown, options?: {
+        context?: Record<string, unknown>;
+        tags?: Record<string, string>;
+        level?: ErrorLevel;
+    }): void;
+    /**
+     * Capture a non-error event you want to surface as an issue
+     * ("deprecated path hit", "we entered the slow code path"). Sentry
+     * captureMessage pattern. Returns silently if not initialised.
+     */
+    captureMessage(message: string, level?: ErrorLevel): void;
+    /**
+     * Attach a tag to every subsequent error report. Tags are key/value
+     * strings (Sentry pattern): `setTag("flow", "checkout")` → every
+     * error from this point on carries `tags.flow === "checkout"`.
+     */
+    setTag(key: string, value: string): void;
+    /** Bulk-set tags. Merges with existing tags. */
+    setTags(tags: Record<string, string>): void;
+    /**
+     * Attach a structured context blob to every subsequent error report.
+     * Unlike tags (flat key/value), context is a named bag of arbitrary
+     * data: `setContext("cart", { items: 3, total: 42.99 })`.
+     */
+    setContext(name: string, data: Record<string, unknown>): void;
+    /**
+     * Add a custom breadcrumb to the rolling buffer. Useful for marking
+     * domain-meaningful moments ("user opened paywall") that aren't
+     * already auto-captured. The buffer caps at 50 entries; old ones
+     * evict.
+     */
+    addBreadcrumb(crumb: Breadcrumb): void;
+    /**
+     * Install a pre-send hook for errors. Return null to drop, or a
+     * modified CapturedError to scrub / rewrite. Sentry's beforeSend
+     * pattern — the only way to redact app-specific PII (auth tokens
+     * in URLs, etc.) before the report leaves the browser.
+     */
+    setErrorBeforeSend(hook: ((err: CapturedError) => CapturedError | null) | null): void;
+    /**
+     * Internal: turn a CapturedError into a Crossdeck event and enqueue
+     * it. Goes through the same queue / persistence / consent / scrub
+     * pipeline as analytics events.
+     */
+    private reportError;
+    /**
+     * GDPR/CCPA "right to be forgotten" — calls the backend's
+     * /v1/identity/forget endpoint to schedule a server-side deletion of
+     * the customer's events and profile, then wipes all local state
+     * (identity, entitlements, queue, super-props, persistent stores).
+     *
+     * Idempotent. Safe to call when no identity has been established
+     * (it just wipes the empty local state).
+     *
+     * After forget() resolves, the SDK is in the same shape as if the
+     * developer had called `Crossdeck.reset()` — a fresh anonymousId is
+     * minted and the next session is a brand new identity-graph entry.
+     */
+    forget(): Promise<void>;
     /**
      * Read the current customer's active entitlements from the server.
      * Updates the local cache so subsequent isEntitled() calls answer
@@ -458,12 +878,21 @@ interface CrossdeckErrorPayload {
     requestId?: string;
     /** HTTP status code if the error came from an API response. */
     status?: number;
+    /**
+     * Server-suggested wait (in milliseconds) before retrying. Populated
+     * from the `Retry-After` response header on 429 / 503. The header
+     * spec allows either delta-seconds or an HTTP-date; the parser below
+     * normalises both to milliseconds. Consumers MUST honour this — the
+     * server is telling you the safe rate.
+     */
+    retryAfterMs?: number;
 }
 declare class CrossdeckError extends Error {
     readonly type: CrossdeckErrorType;
     readonly code: string;
     readonly requestId?: string;
     readonly status?: number;
+    readonly retryAfterMs?: number;
     constructor(payload: CrossdeckErrorPayload);
 }
 
@@ -526,9 +955,45 @@ declare class MemoryStorage implements KeyValueStorage {
  * fetch shim, no transitive deps.
  */
 declare const SDK_NAME = "@cross-deck/web";
-declare const SDK_VERSION = "0.6.0";
+declare const SDK_VERSION = "1.0.0";
 declare const DEFAULT_BASE_URL = "https://api.cross-deck.com/v1";
 
+/**
+ * Machine-readable index of every error code the SDK can throw, with
+ * a short description and a hint on what action to take. Published
+ * verbatim as `crossdeck-error-codes.json` in the npm tarball so AI
+ * integration assistants, error-aggregator dashboards (Sentry,
+ * DataDog), and the Crossdeck dashboard can render human-friendly
+ * messages without parsing freeform `message` strings.
+ *
+ * Stripe publishes the same surface at stripe.com/docs/error-codes;
+ * developers love it because every code has a canonical "what does
+ * this mean / what should I do" answer.
+ *
+ * Adding a new error code:
+ *   1. Add the code string to the union in `errors.ts` (where used).
+ *   2. Add an entry here.
+ *   3. The next `npm run build` regenerates the JSON sidecar.
+ *
+ * Keep entries terse — the consumer surfaces this in tooltips and
+ * automated tickets, not in long-form docs.
+ */
+interface ErrorCodeEntry {
+    /** The string thrown as CrossdeckError.code. */
+    code: string;
+    /** CrossdeckError.type — broad category. */
+    type: "authentication_error" | "permission_error" | "invalid_request_error" | "rate_limit_error" | "internal_error" | "network_error" | "configuration_error";
+    /** One-sentence description. Surfaced verbatim in dashboards. */
+    description: string;
+    /** What the developer should do. Imperative phrasing. */
+    resolution: string;
+    /** True for codes the SDK can auto-recover from (no developer action). */
+    retryable: boolean;
+}
+declare const CROSSDECK_ERROR_CODES: readonly ErrorCodeEntry[];
+/** Lookup helper — returns the entry matching a CrossdeckError.code, or undefined. */
+declare function getErrorCode(code: string): ErrorCodeEntry | undefined;
+
 /**
  * Device + environment enrichment.
  *
@@ -563,4 +1028,4 @@ interface DeviceInfo {
     appVersion?: string;
 }
 
-export { type AliasResult, type AuditRail, type AutoTrackOptions, Crossdeck, CrossdeckClient, CrossdeckError, type CrossdeckErrorPayload, type CrossdeckErrorType, type CrossdeckOptions, DEFAULT_BASE_URL, type DeviceInfo, type Diagnostics, type EntitlementsListResponse, type Environment, type EventProperties, type HeartbeatResponse, type IdentifyOptions, type KeyValueStorage, MemoryStorage, type Platform, type PublicEntitlement, type PurchaseResult, SDK_NAME, SDK_VERSION };
+export { type AliasResult, type AuditRail, type AutoTrackOptions, type Breadcrumb, type BreadcrumbCategory, type BreadcrumbLevel, CROSSDECK_ERROR_CODES, type CapturedError, type ConsentState, Crossdeck, CrossdeckClient, CrossdeckError, type CrossdeckErrorPayload, type CrossdeckErrorType, type CrossdeckOptions, DEFAULT_BASE_URL, type DeviceInfo, type Diagnostics, type EntitlementsListResponse, type Environment, type ErrorCodeEntry, type ErrorLevel, type EventProperties, type GroupTraits, type HeartbeatResponse, type IdentifyOptions, type KeyValueStorage, MemoryStorage, type Platform, type PublicEntitlement, type PurchaseResult, SDK_NAME, SDK_VERSION, type StackFrame, getErrorCode };