@fixback/node 0.2.0

package/src/nestjs.ts

@@ -0,0 +1,123 @@
+/**
+ * The **NestJS** adapter (`@fixback/node/nestjs`, story 2) — a module + exception
+ * filter that capture thrown request errors with server context, **without changing
+ * the app's behaviour**.
+ *
+ * - {@link FixbackExceptionFilter} extends Nest's `BaseExceptionFilter`: it captures
+ *   the exception (`handled: true`, with the request's route pattern / method /
+ *   status) and then delegates to `super.catch`, so Nest still produces the exact
+ *   HTTP response it would have. Registered globally via `APP_FILTER`.
+ * - {@link FixbackModule} wires that filter and applies the request-context
+ *   middleware (AsyncLocalStorage correlation) to every route. Register it with
+ *   `FixbackModule.forRoot()`.
+ *
+ * `@nestjs/common` and `@nestjs/core` are **optional peer dependencies** — this module
+ * is only loaded when you import `@fixback/node/nestjs`, so an Express-only or
+ * manual-capture install never pulls Nest in.
+ */
+
+import "reflect-metadata";
+
+import {
+  type ArgumentsHost,
+  Catch,
+  type DynamicModule,
+  HttpException,
+  type MiddlewareConsumer,
+  Module,
+  type NestModule,
+} from "@nestjs/common";
+import { APP_FILTER, BaseExceptionFilter } from "@nestjs/core";
+
+import {
+  type CaptureClient,
+  captureException as moduleCaptureException,
+  getClient,
+} from "./client";
+import { createRequestContextMiddleware } from "./context";
+import {
+  errorStatus,
+  type HttpRequestLike,
+  type HttpResponseLike,
+  serverContextFromRequest,
+} from "./http";
+
+/** Files through the active module client by default. */
+const defaultClient: CaptureClient = {
+  captureException: (error, context) => moduleCaptureException(error, context),
+};
+
+/** Resolve the status: an `HttpException`'s own status, else the shared heuristic. */
+function nestStatus(exception: unknown, res: HttpResponseLike): number {
+  if (exception instanceof HttpException) {
+    const status = exception.getStatus();
+    if (typeof status === "number") return status;
+  }
+  return errorStatus(exception, res);
+}
+
+/**
+ * Capture a Nest exception with the request's server context (`handled: true`).
+ * Exported so it can be unit-tested against a fake `ArgumentsHost`; the filter uses
+ * it. Never throws — a capture failure must not break the request pipeline.
+ */
+export function captureNestException(
+  exception: unknown,
+  host: ArgumentsHost,
+  client: CaptureClient = defaultClient,
+): void {
+  try {
+    const isHttp = typeof host.getType === "function" ? host.getType() === "http" : true;
+    if (!isHttp) {
+      client.captureException(exception, { handled: true });
+      return;
+    }
+    const http = host.switchToHttp();
+    const req = http.getRequest<HttpRequestLike>();
+    const res = (http.getResponse<HttpResponseLike>() ?? {}) as HttpResponseLike;
+    const base = req ? serverContextFromRequest(req) : {};
+    const server = { ...base, statusCode: nestStatus(exception, res) };
+    client.captureException(exception, { handled: true, server });
+  } catch {
+    try {
+      client.captureException(exception, { handled: true });
+    } catch {
+      /* capture must never break the pipeline */
+    }
+  }
+}
+
+/**
+ * A global exception filter that captures every thrown request error and then hands
+ * off to Nest's `BaseExceptionFilter`, so the HTTP response is exactly what Nest
+ * would have produced (no behaviour change).
+ */
+@Catch()
+export class FixbackExceptionFilter extends BaseExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost): void {
+    captureNestException(exception, host);
+    super.catch(exception, host);
+  }
+}
+
+/**
+ * The Fixback NestJS module. Register with `imports: [FixbackModule.forRoot()]`; it
+ * installs the global {@link FixbackExceptionFilter} and applies the request-context
+ * middleware to every route.
+ */
+@Module({})
+export class FixbackModule implements NestModule {
+  static forRoot(): DynamicModule {
+    return {
+      module: FixbackModule,
+      providers: [{ provide: APP_FILTER, useClass: FixbackExceptionFilter }],
+    };
+  }
+
+  configure(consumer: MiddlewareConsumer): void {
+    const requestIdHeader = getClient()?.requestIdHeader;
+    consumer
+      .apply(createRequestContextMiddleware(requestIdHeader ? { requestIdHeader } : {}))
+      .forRoutes("*");
+  }
+}

package/src/process.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { installProcessHandlers, type ProcessLike } from "./process";
+
+type Listener = (...args: unknown[]) => void;
+
+/** A tiny EventEmitter-shaped stand-in for `process` (never the real one, in tests). */
+class FakeProcess implements ProcessLike {
+  private readonly map = new Map<string, Listener[]>();
+  on(event: string, listener: Listener): this {
+    this.map.set(event, [...(this.map.get(event) ?? []), listener]);
+    return this;
+  }
+  removeListener(event: string, listener: Listener): this {
+    this.map.set(event, (this.map.get(event) ?? []).filter((l) => l !== listener));
+    return this;
+  }
+  listeners(event: string): Listener[] {
+    return [...(this.map.get(event) ?? [])];
+  }
+  emit(event: string, ...args: unknown[]): void {
+    for (const l of [...(this.map.get(event) ?? [])]) l(...args);
+  }
+}
+
+function fakeSink() {
+  const captures: Array<{ error: unknown; handled?: boolean }> = [];
+  let flushes = 0;
+  return {
+    captures,
+    get flushes() {
+      return flushes;
+    },
+    sink: {
+      captureException(error: unknown, context?: { handled?: boolean }) {
+        captures.push({ error, handled: context?.handled });
+      },
+      flush: async () => {
+        flushes += 1;
+      },
+    },
+  };
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe("installProcessHandlers", () => {
+  it("adds an uncaughtException and unhandledRejection listener, and uninstall removes them", () => {
+    const proc = new FakeProcess();
+    const { sink } = fakeSink();
+    const uninstall = installProcessHandlers(
+      sink,
+      { captureUncaughtException: true, captureUnhandledRejection: true },
+      { process: proc, onFatalError: () => {} },
+    );
+    expect(proc.listeners("uncaughtException")).toHaveLength(1);
+    expect(proc.listeners("unhandledRejection")).toHaveLength(1);
+    uninstall();
+    expect(proc.listeners("uncaughtException")).toHaveLength(0);
+    expect(proc.listeners("unhandledRejection")).toHaveLength(0);
+  });
+
+  it("installs only the handlers the gates enable", () => {
+    const proc = new FakeProcess();
+    const { sink } = fakeSink();
+    installProcessHandlers(
+      sink,
+      { captureUncaughtException: false, captureUnhandledRejection: true },
+      { process: proc, onFatalError: () => {} },
+    );
+    expect(proc.listeners("uncaughtException")).toHaveLength(0);
+    expect(proc.listeners("unhandledRejection")).toHaveLength(1);
+  });
+
+  it("captures an uncaught exception as handled:false", () => {
+    const proc = new FakeProcess();
+    const { sink, captures } = fakeSink();
+    installProcessHandlers(
+      sink,
+      { captureUncaughtException: true, captureUnhandledRejection: false },
+      { process: proc, onFatalError: () => {} },
+    );
+    proc.emit("uncaughtException", new Error("crash"), "uncaughtException");
+    expect(captures).toHaveLength(1);
+    expect((captures[0]!.error as Error).message).toBe("crash");
+    expect(captures[0]!.handled).toBe(false);
+  });
+
+  it("preserves the default crash — flushes then calls onFatalError — when it is the only listener", async () => {
+    const proc = new FakeProcess();
+    const { sink } = fakeSink();
+    const onFatalError = vi.fn();
+    installProcessHandlers(
+      sink,
+      { captureUncaughtException: true, captureUnhandledRejection: false },
+      { process: proc, onFatalError },
+    );
+    const boom = new Error("boom");
+    proc.emit("uncaughtException", boom);
+    await tick();
+    expect(onFatalError).toHaveBeenCalledTimes(1);
+    expect(onFatalError).toHaveBeenCalledWith(boom);
+  });
+
+  it("does NOT change exit behaviour when the app has its own uncaughtException listener", async () => {
+    const proc = new FakeProcess();
+    const { sink, captures } = fakeSink();
+    const onFatalError = vi.fn();
+    installProcessHandlers(
+      sink,
+      { captureUncaughtException: true, captureUnhandledRejection: false },
+      { process: proc, onFatalError },
+    );
+    // The host installed its own handler — it owns the exit decision.
+    proc.on("uncaughtException", () => {});
+    proc.emit("uncaughtException", new Error("x"));
+    await tick();
+    expect(captures).toHaveLength(1); // still captured
+    expect(onFatalError).not.toHaveBeenCalled(); // but we never force an exit
+  });
+
+  it("captures an unhandled rejection as handled:false and never forces an exit (story 5)", async () => {
+    const proc = new FakeProcess();
+    const { sink, captures } = fakeSink();
+    const onFatalError = vi.fn();
+    installProcessHandlers(
+      sink,
+      { captureUncaughtException: false, captureUnhandledRejection: true },
+      { process: proc, onFatalError },
+    );
+    proc.emit("unhandledRejection", new Error("rejected"), Promise.resolve());
+    await tick();
+    expect(captures).toHaveLength(1);
+    expect((captures[0]!.error as Error).message).toBe("rejected");
+    expect(captures[0]!.handled).toBe(false);
+    expect(onFatalError).not.toHaveBeenCalled();
+  });
+
+  it("never throws out of the handler when capture itself fails", () => {
+    const proc = new FakeProcess();
+    const throwingSink = {
+      captureException() {
+        throw new Error("capture blew up");
+      },
+      flush: async () => {},
+    };
+    installProcessHandlers(
+      throwingSink,
+      { captureUncaughtException: true, captureUnhandledRejection: false },
+      { process: proc, onFatalError: () => {} },
+    );
+    expect(() => proc.emit("uncaughtException", new Error("x"))).not.toThrow();
+  });
+});

package/src/process.ts

@@ -0,0 +1,153 @@
+/**
+ * Process-level capture (spec §D9, stories 4 & 5) — the *polite* `uncaughtException`
+ * and `unhandledRejection` handlers that **never change the app's exit behaviour**.
+ *
+ * The subtlety: merely *adding* an `uncaughtException` listener suppresses Node's
+ * default crash. So to stay polite:
+ *
+ * - **uncaughtException:** capture (`handled: false`), then — only when we are the
+ *   *sole* listener (the app installed none of its own) — best-effort flush and hand
+ *   off to `onFatalError`, which preserves Node's default (log + non-zero exit). When
+ *   the app has its own handler, we do nothing further: the app owns the exit.
+ * - **unhandledRejection:** capture (`handled: false`) and stop. We never escalate a
+ *   rejection to a process exit — exactly the "never turn a logged rejection into an
+ *   exit" guarantee (story 5).
+ *
+ * Everything is wrapped so a capture failure can never break the handler.
+ */
+
+/** The `process` slice these handlers touch — injectable so tests never touch the real one. */
+export interface ProcessLike {
+  on(event: string, listener: (...args: unknown[]) => void): unknown;
+  removeListener(event: string, listener: (...args: unknown[]) => void): unknown;
+  listeners(event: string): Array<(...args: unknown[]) => void>;
+}
+
+/** What a captured process error is filed through — the {@link FixbackClient} satisfies it. */
+export interface CaptureSink {
+  captureException(error: unknown, context?: { handled?: boolean }): void;
+  flush(): Promise<void>;
+}
+
+/** Which process handlers to install. */
+export interface ProcessHandlerOptions {
+  readonly captureUncaughtException: boolean;
+  readonly captureUnhandledRejection: boolean;
+  /** How long a fatal-path flush may take before the process exits anyway. */
+  readonly flushTimeoutMs?: number;
+}
+
+/** Injectable collaborators for {@link installProcessHandlers}. */
+export interface ProcessHandlerDeps {
+  readonly process?: ProcessLike;
+  /**
+   * Preserve Node's default fatal behaviour after a sole-listener uncaught exception.
+   * Defaults to logging the error and exiting non-zero (exactly what Node would do).
+   */
+  readonly onFatalError?: (error: unknown) => void;
+}
+
+const DEFAULT_FLUSH_TIMEOUT_MS = 2_000;
+
+/** The real `process`, when running on Node. */
+function resolveProcess(): ProcessLike | undefined {
+  const g = globalThis as unknown as { process?: ProcessLike };
+  const proc = g.process;
+  return proc && typeof proc.on === "function" ? proc : undefined;
+}
+
+/** Node's default fatal behaviour: print the error and exit non-zero. */
+function defaultOnFatalError(proc: ProcessLike): (error: unknown) => void {
+  return (error: unknown) => {
+    try {
+      console.error(error);
+    } catch {
+      /* a hostile console must not stop the exit */
+    }
+    const exit = (proc as { exit?: (code?: number) => never }).exit;
+    if (typeof exit === "function") {
+      try {
+        exit(1);
+      } catch {
+        /* exit is terminal; nothing to do if it throws */
+      }
+    }
+  };
+}
+
+/** Race a flush against a timeout so a wedged transport can't hang a crashing process. */
+function flushWithTimeout(flush: () => Promise<void>, ms: number): Promise<void> {
+  let result: Promise<void>;
+  try {
+    result = Promise.resolve(flush());
+  } catch {
+    return Promise.resolve();
+  }
+  if (ms <= 0) return result.catch(() => {});
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<void>((resolve) => {
+    timer = setTimeout(resolve, ms);
+  });
+  return Promise.race([result.catch(() => {}), timeout]).finally(() => {
+    if (timer !== undefined) clearTimeout(timer);
+  });
+}
+
+/**
+ * Install the polite process handlers for `sink`, returning an uninstall function.
+ * A no-op (and a no-op uninstall) when no `process` is available or when both gates
+ * are off.
+ */
+export function installProcessHandlers(
+  sink: CaptureSink,
+  options: ProcessHandlerOptions,
+  deps: ProcessHandlerDeps = {},
+): () => void {
+  const proc = deps.process ?? resolveProcess();
+  if (!proc) return () => {};
+
+  const onFatalError = deps.onFatalError ?? defaultOnFatalError(proc);
+  const flushTimeoutMs = options.flushTimeoutMs ?? DEFAULT_FLUSH_TIMEOUT_MS;
+
+  const onUncaughtException = (...args: unknown[]): void => {
+    const error = args[0];
+    try {
+      sink.captureException(error, { handled: false });
+    } catch {
+      /* capture must never break the handler */
+    }
+    // If the app installed its own uncaughtException handler, it owns the exit — we
+    // must not force one (that would *change* its behaviour). Only when we are the
+    // sole listener do we preserve Node's default crash.
+    const others = proc.listeners("uncaughtException").filter((l) => l !== onUncaughtException);
+    if (others.length > 0) return;
+    void flushWithTimeout(() => sink.flush(), flushTimeoutMs).finally(() => {
+      try {
+        onFatalError(error);
+      } catch {
+        /* the fatal handler is terminal */
+      }
+    });
+  };
+
+  const onUnhandledRejection = (...args: unknown[]): void => {
+    // Capture only — never escalate a rejection to a process exit (story 5).
+    try {
+      sink.captureException(args[0], { handled: false });
+    } catch {
+      /* capture must never break the handler */
+    }
+  };
+
+  if (options.captureUncaughtException) proc.on("uncaughtException", onUncaughtException);
+  if (options.captureUnhandledRejection) proc.on("unhandledRejection", onUnhandledRejection);
+
+  return () => {
+    if (options.captureUncaughtException) {
+      proc.removeListener("uncaughtException", onUncaughtException);
+    }
+    if (options.captureUnhandledRejection) {
+      proc.removeListener("unhandledRejection", onUnhandledRejection);
+    }
+  };
+}

package/src/stack.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+
+import { extractError, extractStructuredFrames } from "./stack";
+
+const V8_STACK = [
+  "TypeError: Cannot read properties of undefined (reading 'id')",
+  "    at renderTotal (/srv/app/dist/checkout.js:88:12)",
+  "    at Object.<anonymous> (/srv/app/dist/server.js:42:5)",
+  "    at processTicksAndRejections (node:internal/process/task_queues:95:5)",
+].join("\n");
+
+describe("extractStructuredFrames", () => {
+  it("parses V8 frames into file/line/column/function, top of stack first", () => {
+    const frames = extractStructuredFrames(V8_STACK);
+    expect(frames[0]).toEqual({
+      file: "/srv/app/dist/checkout.js",
+      line: 88,
+      column: 12,
+      function: "renderTotal",
+    });
+    expect(frames[1]).toEqual({
+      file: "/srv/app/dist/server.js",
+      line: 42,
+      column: 5,
+      function: "Object.<anonymous>",
+    });
+  });
+
+  it("scrubs credentials and query strings from a frame's file url (shared-core scrub)", () => {
+    const stack = [
+      "Error: boom",
+      "    at handler (https://user:pass@cdn.example.com/app.js?token=secret123:5:1)",
+    ].join("\n");
+    const [frame] = extractStructuredFrames(stack);
+    expect(frame?.file).not.toContain("token=secret123");
+    expect(frame?.file).not.toContain("user:pass@");
+    expect(frame?.file).toContain("cdn.example.com/app.js");
+  });
+
+  it("caps the number of frames it keeps", () => {
+    const many = ["Error: boom"]
+      .concat(Array.from({ length: 100 }, (_, i) => `    at fn${i} (/srv/app/f${i}.js:${i + 1}:1)`))
+      .join("\n");
+    expect(extractStructuredFrames(many, 5)).toHaveLength(5);
+  });
+
+  it("returns no frames for a missing or stackless input", () => {
+    expect(extractStructuredFrames(undefined)).toEqual([]);
+    expect(extractStructuredFrames("")).toEqual([]);
+    expect(extractStructuredFrames("Error: no frames here")).toEqual([]);
+  });
+});
+
+describe("extractError", () => {
+  it("distils an Error into type / value / stack", () => {
+    const err = new TypeError("nope");
+    const extracted = extractError(err);
+    expect(extracted.type).toBe("TypeError");
+    expect(extracted.value).toBe("nope");
+    expect(extracted.stack).toBe(err.stack);
+  });
+
+  it("falls back to Error for an anonymous error and keeps an empty message", () => {
+    const bare = new Error();
+    expect(extractError(bare).type).toBe("Error");
+    expect(extractError(bare).value).toBe("");
+  });
+
+  it("distils a thrown string", () => {
+    expect(extractError("kaboom")).toEqual({ type: "Error", value: "kaboom", stack: undefined });
+  });
+
+  it("distils a thrown non-error object without throwing", () => {
+    const extracted = extractError({ weird: true });
+    expect(extracted.type).toBe("Error");
+    expect(typeof extracted.value).toBe("string");
+    expect(extracted.stack).toBeUndefined();
+  });
+
+  it("uses a custom error subclass name as the type", () => {
+    class PaymentError extends Error {
+      constructor(message: string) {
+        super(message);
+        this.name = "PaymentError";
+      }
+    }
+    expect(extractError(new PaymentError("declined")).type).toBe("PaymentError");
+  });
+});

package/src/stack.ts

@@ -0,0 +1,153 @@
+/**
+ * Turning a thrown value into the pieces a capture needs: the distilled
+ * `type | value | stack` a fingerprint is built from ({@link extractError}), and the
+ * **structured stack frames** for the wire ({@link extractStructuredFrames}).
+ *
+ * The distillation mirrors the browser SDK's exactly (`packages/sdk/src/error-capture.ts`)
+ * — `type = error.name`, `value = error.message`, `stack = error.stack` — so the same
+ * logical error yields the same shared-core fingerprint on either surface (the
+ * ADR-0028 parity guarantee). Frame parsing keeps the full script path (server-side
+ * symbolication matches it against uploaded sourcemaps) but scrubs each URL through
+ * the shared-core scrubber before it can leave the process.
+ */
+
+import { type CapturedFrame, scrubUrl } from "@fixback/sdk-core";
+
+/** The most structured frames shipped per error (mirrors the server's cap). */
+const STRUCTURED_FRAME_LIMIT = 30;
+
+/** The distilled shape a fingerprint and a report are built from. */
+export interface ExtractedError {
+  readonly type: string;
+  readonly value: string;
+  readonly stack?: string;
+}
+
+interface ErrorLike {
+  name?: unknown;
+  message?: unknown;
+  stack?: unknown;
+}
+
+/** Coerce any value to a string without throwing (a hostile `toString` can throw). */
+function asString(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (value == null) return "";
+  try {
+    return String(value);
+  } catch {
+    return "";
+  }
+}
+
+/** Best-effort JSON for a non-Error thrown object, falling back to `String`. */
+function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value) ?? asString(value);
+  } catch {
+    return asString(value);
+  }
+}
+
+/** True for a duck-typed error (a cross-realm Error, or an error-shaped throwable). */
+function isErrorLike(value: object): value is ErrorLike {
+  const err = value as ErrorLike;
+  return (
+    typeof err.message === "string" ||
+    typeof err.stack === "string" ||
+    typeof err.name === "string"
+  );
+}
+
+/**
+ * Distil any thrown value into `{ type, value, stack }`. An `Error` (or error-shaped
+ * object) contributes its `name` / `message` / `stack`; a thrown string becomes the
+ * value; any other value is stringified. Never throws.
+ */
+export function extractError(input: unknown): ExtractedError {
+  if (input instanceof Error) {
+    return {
+      type: asString(input.name) || "Error",
+      value: asString(input.message),
+      stack: typeof input.stack === "string" ? input.stack : undefined,
+    };
+  }
+  if (typeof input === "string") {
+    return { type: "Error", value: input, stack: undefined };
+  }
+  if (input && typeof input === "object") {
+    if (isErrorLike(input)) {
+      const err = input as ErrorLike;
+      return {
+        type: asString(err.name) || "Error",
+        value: asString(err.message),
+        stack: typeof err.stack === "string" ? err.stack : undefined,
+      };
+    }
+    return { type: "Error", value: safeStringify(input), stack: undefined };
+  }
+  return { type: "Error", value: asString(input), stack: undefined };
+}
+
+/** Split a `file:line:col` location into parts; `null` when it has no line. */
+function parseLocation(
+  location: string,
+): { file: string; line: number; column: number | null } | null {
+  // The file may itself contain colons (https://…, node:internal/…), so split from
+  // the right: the trailing `:line(:col)?` are the numeric groups.
+  const match = location.match(/^(.*?):(\d+)(?::(\d+))?$/);
+  if (!match) return null;
+  const file = match[1] ?? "";
+  if (file.length === 0 || file === "native" || file.includes("<anonymous>")) {
+    return null;
+  }
+  const line = Number(match[2]);
+  if (!Number.isFinite(line)) return null;
+  const column = match[3] !== undefined ? Number(match[3]) : null;
+  return { file, line, column };
+}
+
+/**
+ * Extract structured frames from a stack for the wire (#117, ADR-0024), top of stack
+ * first. Keeps the full (scrubbed) script path so server-side symbolication can match
+ * it against uploaded sourcemaps; skips unlocatable frames (`native`, `<anonymous>`,
+ * eval); caps the count. V8 is Node's format; the Firefox/Safari form is handled too
+ * so the parser matches the browser SDK's exactly.
+ */
+export function extractStructuredFrames(
+  stack: string | undefined,
+  limit = STRUCTURED_FRAME_LIMIT,
+): CapturedFrame[] {
+  if (typeof stack !== "string" || stack.length === 0) return [];
+  const frames: CapturedFrame[] = [];
+  for (const raw of stack.split("\n")) {
+    if (frames.length >= limit) break;
+    const line = raw.trim();
+    let fn: string | null = null;
+    let location: string | null = null;
+    // V8: "at fn (loc)" | "at loc"
+    const v8Named = line.match(/^at\s+(.+?)\s+\((.+)\)$/);
+    const v8Bare = v8Named ? null : line.match(/^at\s+(.+)$/);
+    const geckoAt = v8Named || v8Bare ? -1 : line.indexOf("@");
+    if (v8Named) {
+      fn = v8Named[1] ?? null;
+      location = v8Named[2] ?? null;
+    } else if (v8Bare) {
+      location = v8Bare[1] ?? null;
+    } else if (geckoAt >= 0) {
+      // Firefox / Safari: "fn@loc" | "@loc"
+      fn = geckoAt > 0 ? line.slice(0, geckoAt) : null;
+      location = line.slice(geckoAt + 1);
+    }
+    if (!location) continue;
+    const parsed = parseLocation(location);
+    if (!parsed) continue;
+    frames.push({
+      file: scrubUrl(parsed.file),
+      line: parsed.line,
+      column: parsed.column,
+      function: fn && fn.length > 0 ? fn : null,
+    });
+  }
+  return frames;
+}