@fixback/node 0.2.0 → 0.3.0

package/src/config.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { DEFAULT_API_URL, resolveConfig } from "./config";
-
-describe("resolveConfig", () => {
-  it("enables capture and derives the ingest endpoint from a secret key", () => {
-    const config = resolveConfig({ secretKey: "sk_live_abc" });
-    expect(config.enabled).toBe(true);
-    expect(config.secretKey).toBe("sk_live_abc");
-    expect(config.apiUrl).toBe(DEFAULT_API_URL);
-    expect(config.errorsEndpoint).toBe(`${DEFAULT_API_URL}/api/errors`);
-  });
-
-  it("stays disabled (fail-quiet) when no secret key is given", () => {
-    // Misconfiguration must never throw — the host server keeps running (story 34).
-    expect(() => resolveConfig({ secretKey: "" })).not.toThrow();
-    expect(resolveConfig({ secretKey: "" }).enabled).toBe(false);
-    expect(resolveConfig({ secretKey: "   " }).enabled).toBe(false);
-    // @ts-expect-error — a caller may omit the key entirely at runtime.
-    expect(resolveConfig({}).enabled).toBe(false);
-  });
-
-  it("honours an explicit enabled:false gate even with a valid key (story 35)", () => {
-    const config = resolveConfig({ secretKey: "sk_live_abc", enabled: false });
-    expect(config.enabled).toBe(false);
-  });
-
-  it("normalises the api url (trailing slashes stripped) before building the endpoint", () => {
-    const config = resolveConfig({
-      secretKey: "sk_live_abc",
-      apiUrl: "https://fixback.acme.dev/",
-    });
-    expect(config.apiUrl).toBe("https://fixback.acme.dev");
-    expect(config.errorsEndpoint).toBe("https://fixback.acme.dev/api/errors");
-  });
-
-  it("carries environment and release through, dropping blank strings", () => {
-    const config = resolveConfig({
-      secretKey: "sk_live_abc",
-      environment: "production",
-      release: "  1.4.2  ",
-    });
-    expect(config.environment).toBe("production");
-    expect(config.release).toBe("1.4.2");
-    expect(resolveConfig({ secretKey: "sk", environment: "  " }).environment).toBeUndefined();
-  });
-
-  it("defaults the batching knobs and clamps the batch to the server maximum", () => {
-    const config = resolveConfig({ secretKey: "sk_live_abc" });
-    expect(config.maxBatchSize).toBe(100);
-    expect(config.flushIntervalMs).toBeGreaterThan(0);
-    expect(config.maxQueueSize).toBeGreaterThan(0);
-
-    // The server rejects batches over 500; a larger request is clamped, not sent oversized.
-    expect(resolveConfig({ secretKey: "sk", maxBatchSize: 5000 }).maxBatchSize).toBe(500);
-    expect(resolveConfig({ secretKey: "sk", maxBatchSize: 0 }).maxBatchSize).toBe(1);
-  });
-
-  it("defaults the process-handler gates on and honours explicit opt-outs", () => {
-    const on = resolveConfig({ secretKey: "sk" });
-    expect(on.captureUncaughtException).toBe(true);
-    expect(on.captureUnhandledRejection).toBe(true);
-
-    const off = resolveConfig({
-      secretKey: "sk",
-      captureUncaughtException: false,
-      captureUnhandledRejection: false,
-    });
-    expect(off.captureUncaughtException).toBe(false);
-    expect(off.captureUnhandledRejection).toBe(false);
-  });
-
-  it("lower-cases the correlation-id header name", () => {
-    expect(resolveConfig({ secretKey: "sk", requestIdHeader: "X-Trace-Id" }).requestIdHeader).toBe(
-      "x-trace-id",
-    );
-    expect(resolveConfig({ secretKey: "sk" }).requestIdHeader).toBe("x-request-id");
-  });
-});

package/src/config.ts

@@ -1,131 +0,0 @@
-/**
- * The `init` options and their resolution into a validated {@link ResolvedConfig}.
- *
- * Resolution is **fail-quiet** (spec #224, story 34): it never throws. A missing
- * secret key or an explicit `enabled: false` leaves the SDK inert (`enabled: false`)
- * rather than raising — a Fixback misconfiguration must never break the host server.
- * Numeric knobs are clamped to safe bounds (the batch to the server's 500-item cap)
- * instead of rejected.
- */
-
-import type { BeforeSend } from "./wire";
-
-/** The default Fixback ingest origin, shared with the browser and Expo SDKs. */
-export const DEFAULT_API_URL = "https://api.fixback.dev";
-
-/** The largest batch the server-error endpoint accepts (`MAX_SERVER_ERROR_BATCH`). */
-const SERVER_MAX_BATCH = 500;
-
-const DEFAULT_MAX_BATCH_SIZE = 100;
-const DEFAULT_FLUSH_INTERVAL_MS = 5_000;
-const DEFAULT_MAX_QUEUE_SIZE = 1_024;
-const DEFAULT_TIMEOUT_MS = 30_000;
-const DEFAULT_REQUEST_ID_HEADER = "x-request-id";
-
-/** Options for {@link init} — the one call that wires backend capture. */
-export interface InitOptions {
-  /**
-   * The Project **secret key** (`sk_…`) the backend authenticates with — the same
-   * key `npx fixback sourcemaps upload` uses (never the publishable key). Without it
-   * the SDK stays inert.
-   */
-  readonly secretKey: string;
-  /** The Fixback ingest origin. Defaults to {@link DEFAULT_API_URL}. */
-  readonly apiUrl?: string;
-  /** The deploy environment (`production` / `staging` / …) stamped on every error. */
-  readonly environment?: string;
-  /** The build **Release** the captured stacks symbolicate against. */
-  readonly release?: string;
-  /** A hook to redact or drop an event before it leaves the process (return `null` to drop). */
-  readonly beforeSend?: BeforeSend;
-  /** Run the built-in default scrubbers before `beforeSend`. Defaults to `true`. */
-  readonly scrub?: boolean;
-  /** Master gate — set `false` to disable all capture (e.g. in local dev). Defaults to `true`. */
-  readonly enabled?: boolean;
-  /** Install the polite `uncaughtException` handler. Defaults to `true`. */
-  readonly captureUncaughtException?: boolean;
-  /** Install the polite `unhandledRejection` handler. Defaults to `true`. */
-  readonly captureUnhandledRejection?: boolean;
-  /** Flush the buffer once it reaches this many errors. Defaults to `100`; capped at `500`. */
-  readonly maxBatchSize?: number;
-  /** Flush a non-empty buffer at least this often, in ms. Defaults to `5000`. */
-  readonly flushIntervalMs?: number;
-  /** Cap the in-memory buffer so a flood can't grow it without bound. Defaults to `1024`. */
-  readonly maxQueueSize?: number;
-  /** Overall per-request transport timeout in ms; `0` disables. Defaults to `30000`. */
-  readonly timeoutMs?: number;
-  /** The header a correlation id is read from. Defaults to `x-request-id`. */
-  readonly requestIdHeader?: string;
-}
-
-/** The validated, defaulted configuration a {@link FixbackClient} runs on. */
-export interface ResolvedConfig {
-  readonly enabled: boolean;
-  readonly secretKey: string;
-  readonly apiUrl: string;
-  readonly errorsEndpoint: string;
-  readonly environment?: string;
-  readonly release?: string;
-  readonly beforeSend?: BeforeSend;
-  readonly scrub: boolean;
-  readonly captureUncaughtException: boolean;
-  readonly captureUnhandledRejection: boolean;
-  readonly maxBatchSize: number;
-  readonly flushIntervalMs: number;
-  readonly maxQueueSize: number;
-  readonly timeoutMs: number;
-  readonly requestIdHeader: string;
-}
-
-/** Trim a string option, returning `undefined` for a blank or non-string value. */
-function trimmed(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined;
-  const out = value.trim();
-  return out.length > 0 ? out : undefined;
-}
-
-/** Normalise an api base URL: trim and strip trailing slashes. */
-function normalizeApiUrl(value: string | undefined): string {
-  const base = trimmed(value) ?? DEFAULT_API_URL;
-  return base.replace(/\/+$/, "") || DEFAULT_API_URL;
-}
-
-/** Clamp a positive-integer option to `[min, max]`, falling back to `fallback`. */
-function clampInt(value: unknown, fallback: number, min: number, max: number): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-  return Math.min(max, Math.max(min, Math.floor(value)));
-}
-
-/**
- * Resolve raw {@link InitOptions} into a validated {@link ResolvedConfig}. Never
- * throws: without a usable secret key (or with `enabled: false`) the result is
- * inert (`enabled: false`), so an inert client can no-op every capture.
- */
-export function resolveConfig(options: InitOptions): ResolvedConfig {
-  const secretKey = trimmed(options.secretKey) ?? "";
-  const apiUrl = normalizeApiUrl(options.apiUrl);
-  const enabled = options.enabled !== false && secretKey.length > 0;
-
-  return {
-    enabled,
-    secretKey,
-    apiUrl,
-    errorsEndpoint: `${apiUrl}/api/errors`,
-    environment: trimmed(options.environment),
-    release: trimmed(options.release),
-    beforeSend: typeof options.beforeSend === "function" ? options.beforeSend : undefined,
-    scrub: options.scrub !== false,
-    captureUncaughtException: options.captureUncaughtException !== false,
-    captureUnhandledRejection: options.captureUnhandledRejection !== false,
-    maxBatchSize: clampInt(options.maxBatchSize, DEFAULT_MAX_BATCH_SIZE, 1, SERVER_MAX_BATCH),
-    flushIntervalMs: clampInt(
-      options.flushIntervalMs,
-      DEFAULT_FLUSH_INTERVAL_MS,
-      0,
-      Number.MAX_SAFE_INTEGER,
-    ),
-    maxQueueSize: clampInt(options.maxQueueSize, DEFAULT_MAX_QUEUE_SIZE, 1, Number.MAX_SAFE_INTEGER),
-    timeoutMs: clampInt(options.timeoutMs, DEFAULT_TIMEOUT_MS, 0, Number.MAX_SAFE_INTEGER),
-    requestIdHeader: (trimmed(options.requestIdHeader) ?? DEFAULT_REQUEST_ID_HEADER).toLowerCase(),
-  };
-}

package/src/context.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  createRequestContextMiddleware,
-  currentServerContext,
-  deriveServerContext,
-  getRequestStore,
-  runWithRequestStore,
-  setRequestUser,
-} from "./context";
-import { routePatternOf } from "./http";
-
-describe("request store (AsyncLocalStorage)", () => {
-  it("exposes the active store inside the scope and nothing outside it", () => {
-    expect(getRequestStore()).toBeUndefined();
-    runWithRequestStore({ req: { method: "GET" } }, () => {
-      expect(getRequestStore()?.req.method).toBe("GET");
-    });
-    expect(getRequestStore()).toBeUndefined();
-  });
-
-  it("setRequestUser writes onto the active store and is a no-op outside a request", () => {
-    expect(() => setRequestUser("u-1")).not.toThrow();
-    runWithRequestStore({ req: {} }, () => {
-      setRequestUser("user-42");
-      expect(getRequestStore()?.user).toBe("user-42");
-    });
-  });
-});
-
-describe("deriveServerContext", () => {
-  it("derives method, route pattern, status, requestId and user — never the concrete path", () => {
-    const ctx = deriveServerContext({
-      req: { method: "POST", route: { path: "/users/:id" }, path: "/users/42" },
-      res: { statusCode: 500 },
-      requestId: "corr-9",
-      user: "user-42",
-    });
-    expect(ctx).toEqual({
-      method: "POST",
-      route: "/users/:id",
-      statusCode: 500,
-      requestId: "corr-9",
-      user: "user-42",
-    });
-    // The concrete path (with the value 42) is never carried.
-    expect(JSON.stringify(ctx)).not.toContain("/users/42");
-  });
-
-  it("returns undefined for no store and omits fields it can't resolve", () => {
-    expect(deriveServerContext(undefined)).toBeUndefined();
-    // No route matched yet, no status, no id → an empty context collapses to undefined.
-    expect(deriveServerContext({ req: {} })).toBeUndefined();
-    expect(deriveServerContext({ req: { method: "GET" } })).toEqual({ method: "GET" });
-  });
-});
-
-describe("createRequestContextMiddleware", () => {
-  it("opens a store carrying a generated correlation id and propagates across awaits", async () => {
-    const middleware = createRequestContextMiddleware();
-    const req = { method: "GET", route: { path: "/health" } };
-    const res = { statusCode: 200 };
-
-    const store = await new Promise<ReturnType<typeof getRequestStore>>((resolve) => {
-      middleware(req, res, async () => {
-        await Promise.resolve();
-        resolve(getRequestStore());
-      });
-    });
-
-    expect(store?.req).toBe(req);
-    expect(store?.res).toBe(res);
-    expect(typeof store?.requestId).toBe("string");
-    expect(store?.requestId?.length).toBeGreaterThan(0);
-  });
-
-  it("adopts an inbound correlation-id header when present", () => {
-    const middleware = createRequestContextMiddleware({ requestIdHeader: "x-request-id" });
-    const req = { method: "GET", headers: { "x-request-id": "trace-abc" }, route: { path: "/x" } };
-    let seen: string | undefined;
-    middleware(req, { statusCode: 200 }, () => {
-      seen = currentServerContext()?.requestId;
-    });
-    expect(seen).toBe("trace-abc");
-  });
-});
-
-describe("routePatternOf", () => {
-  it("joins a mounted router's base with the route pattern", () => {
-    expect(routePatternOf({ baseUrl: "/api", route: { path: "/users/:id" } })).toBe(
-      "/api/users/:id",
-    );
-    expect(routePatternOf({ route: { path: "/health" } })).toBe("/health");
-  });
-
-  it("omits the route entirely when none matched (never leaks the concrete path)", () => {
-    expect(routePatternOf({ path: "/users/42" })).toBeUndefined();
-  });
-});

package/src/context.ts

@@ -1,124 +0,0 @@
-/**
- * Per-request correlation via Node **AsyncLocalStorage** (spec §D9, ADR-0025) — so a
- * captured error carries the in-flight request's context without the developer
- * threading a context object through every call.
- *
- * The request-context middleware opens a store holding the request/response refs and
- * a correlation id; the transport reads {@link currentServerContext} at capture time,
- * so the route pattern and status are read *late* (once the router has matched and the
- * status is set), not at request start. `setRequestUser` lets the app attach its own
- * user ref — the SDK never scrapes identity from the request itself.
- */
-
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
-
-import { type HttpRequestLike, type HttpResponseLike, type NextFunction, routePatternOf } from "./http";
-import type { ServerContext } from "./wire";
-
-/** What the ALS store carries for one in-flight request. */
-export interface RequestStore {
-  readonly req: HttpRequestLike;
-  readonly res?: HttpResponseLike;
-  /** The correlation id (inbound header when present, else generated). */
-  readonly requestId?: string;
-  /** The app-supplied user ref, written by {@link setRequestUser}. Never scraped. */
-  user?: string;
-}
-
-const storage = new AsyncLocalStorage<RequestStore>();
-
-/** The active request store, or `undefined` outside a request scope. */
-export function getRequestStore(): RequestStore | undefined {
-  return storage.getStore();
-}
-
-/** Run `fn` (and everything it awaits) with `store` as the active request store. */
-export function runWithRequestStore<T>(store: RequestStore, fn: () => T): T {
-  return storage.run(store, fn);
-}
-
-/**
- * Attach an **app-supplied** user reference to the current request, so any error
- * captured during it carries the user. A no-op outside a request scope (never
- * throws). The SDK never derives identity from the request — only what you pass here.
- */
-export function setRequestUser(user: string): void {
-  const store = storage.getStore();
-  if (store && typeof user === "string" && user.length > 0) store.user = user;
-}
-
-/**
- * Derive the private-by-default {@link ServerContext} from a request store: the HTTP
- * method, the route **pattern**, the resolved status, the correlation id, and the
- * app-supplied user ref. Returns `undefined` when there is no store or nothing
- * resolvable — never the concrete path, a body, a header, or a query value.
- */
-export function deriveServerContext(store: RequestStore | undefined): ServerContext | undefined {
-  if (!store) return undefined;
-  const ctx: {
-    method?: string;
-    route?: string;
-    statusCode?: number;
-    requestId?: string;
-    user?: string;
-  } = {};
-
-  const method = store.req.method;
-  if (typeof method === "string" && method.length > 0) ctx.method = method;
-
-  const route = routePatternOf(store.req);
-  if (route) ctx.route = route;
-
-  const status = store.res?.statusCode;
-  if (typeof status === "number" && status > 0) ctx.statusCode = status;
-
-  if (store.requestId) ctx.requestId = store.requestId;
-  if (store.user) ctx.user = store.user;
-
-  return Object.keys(ctx).length > 0 ? ctx : undefined;
-}
-
-/** The {@link ServerContext} for the active request, or `undefined` outside one. */
-export function currentServerContext(): ServerContext | undefined {
-  return deriveServerContext(storage.getStore());
-}
-
-/** Read a correlation id from the configured header, taking the first if repeated. */
-function readRequestId(req: HttpRequestLike, header: string): string | undefined {
-  const raw = req.headers?.[header];
-  const value = Array.isArray(raw) ? raw[0] : raw;
-  if (typeof value !== "string") return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-/** Options for {@link createRequestContextMiddleware}. */
-export interface RequestContextOptions {
-  /** The header a correlation id is read from. Defaults to `x-request-id`. */
-  readonly requestIdHeader?: string;
-}
-
-/**
- * Build the Express-style request-context middleware: it opens an ALS store for the
- * request (adopting an inbound correlation id, or minting one) and runs the rest of
- * the request within it. Shared by the Express adapter and the NestJS module so both
- * frameworks get per-request correlation the same way.
- */
-export function createRequestContextMiddleware(
-  options: RequestContextOptions = {},
-): (req: HttpRequestLike, res: HttpResponseLike, next: NextFunction) => void {
-  const header = (options.requestIdHeader ?? "x-request-id").toLowerCase();
-  return function fixbackRequestContext(
-    req: HttpRequestLike,
-    res: HttpResponseLike,
-    next: NextFunction,
-  ): void {
-    const store: RequestStore = {
-      req,
-      res,
-      requestId: readRequestId(req, header) ?? randomUUID(),
-    };
-    runWithRequestStore(store, () => next());
-  };
-}

package/src/express.test.ts

@@ -1,112 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-
-import { close as moduleClose, FixbackClient, init } from "./client";
-import { resolveConfig } from "./config";
-import { fixbackErrorHandler, fixbackRequestContext } from "./express";
-import type { CaptureTransport } from "./transport";
-import type { ServerErrorPayload } from "./wire";
-
-function recorder(): { enqueued: ServerErrorPayload[]; transport: CaptureTransport } {
-  const enqueued: ServerErrorPayload[] = [];
-  return {
-    enqueued,
-    transport: {
-      enqueue: (payload) => enqueued.push(payload),
-      flush: async () => {},
-      close: async () => {},
-    },
-  };
-}
-
-const makeClient = (transport: CaptureTransport) =>
-  new FixbackClient(resolveConfig({ secretKey: "sk" }), { transport });
-
-describe("fixbackErrorHandler + fixbackRequestContext", () => {
-  it("captures a request error with server context (handled:true) and forwards it to next", () => {
-    const { enqueued, transport } = recorder();
-    const client = makeClient(transport);
-    const contextMiddleware = fixbackRequestContext();
-    const errorHandler = fixbackErrorHandler({ client });
-
-    const req = { method: "GET", route: { path: "/boom/:id" }, path: "/boom/1" };
-    const res = { statusCode: 200 };
-    const error = new Error("kaboom");
-    let forwarded: unknown;
-
-    contextMiddleware(req, res, () => {
-      // Simulate a route throwing and Express routing it to the error handler.
-      errorHandler(error, req, res, (e) => {
-        forwarded = e;
-      });
-    });
-
-    expect(forwarded).toBe(error); // never swallowed — the app's own handling still runs
-    expect(enqueued).toHaveLength(1);
-    expect(enqueued[0]!.handled).toBe(true);
-    expect(enqueued[0]!.server?.method).toBe("GET");
-    expect(enqueued[0]!.server?.route).toBe("/boom/:id");
-    // No err.status and res still 200 → a sensible 500 for an unhandled request error.
-    expect(enqueued[0]!.server?.statusCode).toBe(500);
-  });
-
-  it("carries the correlation id opened by the request-context middleware", () => {
-    const { enqueued, transport } = recorder();
-    const client = makeClient(transport);
-    const contextMiddleware = fixbackRequestContext();
-    const errorHandler = fixbackErrorHandler({ client });
-
-    const req = { method: "POST", route: { path: "/x" }, headers: { "x-request-id": "corr-77" } };
-    const res = { statusCode: 200 };
-    contextMiddleware(req, res, () => {
-      errorHandler(new Error("boom"), req, res, () => {});
-    });
-
-    expect(enqueued[0]!.server?.requestId).toBe("corr-77");
-  });
-
-  it("derives the status from an http-errors-style status on the error", () => {
-    const { enqueued, transport } = recorder();
-    const client = makeClient(transport);
-    const errorHandler = fixbackErrorHandler({ client });
-    const error = Object.assign(new Error("forbidden"), { statusCode: 403 });
-
-    let forwarded: unknown;
-    errorHandler(error, { method: "GET", route: { path: "/y" } }, { statusCode: 200 }, (e) => {
-      forwarded = e;
-    });
-
-    expect(forwarded).toBe(error);
-    expect(enqueued[0]!.server).toEqual({ method: "GET", route: "/y", statusCode: 403 });
-  });
-
-  it("still forwards the error when capture itself throws (never breaks the app)", () => {
-    const throwingClient = {
-      captureException() {
-        throw new Error("capture blew up");
-      },
-    };
-    const errorHandler = fixbackErrorHandler({ client: throwingClient });
-    const original = new Error("x");
-    let forwarded: unknown;
-    errorHandler(original, {}, {}, (e) => {
-      forwarded = e;
-    });
-    expect(forwarded).toBe(original);
-  });
-
-  it("uses the active module client when no explicit client is given", async () => {
-    const { enqueued, transport } = recorder();
-    init(
-      { secretKey: "sk", captureUncaughtException: false, captureUnhandledRejection: false },
-      { transport },
-    );
-    const errorHandler = fixbackErrorHandler();
-    errorHandler(new Error("via module"), { method: "GET", route: { path: "/z" } }, { statusCode: 500 }, () => {});
-    expect(enqueued).toHaveLength(1);
-    await moduleClose();
-  });
-
-  afterEach(async () => {
-    await moduleClose();
-  });
-});

package/src/express.ts

@@ -1,85 +0,0 @@
-/**
- * The **Express** adapter (`@fixback/node/express`, story 3) — two middlewares:
- *
- * - {@link fixbackRequestContext}: mount **before** your routes. It opens the
- *   per-request AsyncLocalStorage scope (correlation id + request/response refs) so a
- *   captured error carries the request without manual threading.
- * - {@link fixbackErrorHandler}: mount **after** your routes (Express recognises a
- *   4-arg middleware as an error handler). It captures an error that reaches
- *   `next(err)` with the request's server context (`handled: true`), then **calls
- *   `next(err)`** so your own error handling still runs — Fixback never swallows the
- *   error and never breaks the request.
- *
- * Uses only structural request/response types, so the SDK needs no `express`
- * dependency; the real Express objects satisfy them.
- */
-
-import {
-  type CaptureClient,
-  captureException as moduleCaptureException,
-  getClient,
-} from "./client";
-import { createRequestContextMiddleware } from "./context";
-import {
-  errorStatus,
-  type HttpRequestLike,
-  type HttpResponseLike,
-  type NextFunction,
-  serverContextFromRequest,
-} from "./http";
-
-/** An Express request-processing middleware (`(req, res, next)`). */
-export type ExpressMiddleware = (
-  req: HttpRequestLike,
-  res: HttpResponseLike,
-  next: NextFunction,
-) => void;
-
-/** An Express error-handling middleware (`(err, req, res, next)`). */
-export type ExpressErrorMiddleware = (
-  error: unknown,
-  req: HttpRequestLike,
-  res: HttpResponseLike,
-  next: NextFunction,
-) => void;
-
-/** Options for {@link fixbackRequestContext}. */
-export interface RequestContextOptions {
-  /** The header a correlation id is read from. Defaults to the client's config, then `x-request-id`. */
-  readonly requestIdHeader?: string;
-}
-
-/** Options for {@link fixbackErrorHandler}. */
-export interface ErrorHandlerOptions {
-  /** The client to file through. Defaults to the active module client (`init`). */
-  readonly client?: CaptureClient;
-}
-
-/**
- * Build the request-context middleware. Mount it before your routes:
- * `app.use(fixbackRequestContext())`.
- */
-export function fixbackRequestContext(options: RequestContextOptions = {}): ExpressMiddleware {
-  const header = options.requestIdHeader ?? getClient()?.requestIdHeader;
-  return createRequestContextMiddleware(header ? { requestIdHeader: header } : {});
-}
-
-/**
- * Build the error-handling middleware. Mount it after your routes:
- * `app.use(fixbackErrorHandler())`. Captures the error (with the request's server
- * context, `handled: true`) and always forwards it via `next(err)`.
- */
-export function fixbackErrorHandler(options: ErrorHandlerOptions = {}): ExpressErrorMiddleware {
-  const client: CaptureClient = options.client ?? {
-    captureException: (error, context) => moduleCaptureException(error, context),
-  };
-  return function fixbackErrorHandlerMiddleware(error, req, res, next): void {
-    try {
-      const server = { ...serverContextFromRequest(req), statusCode: errorStatus(error, res) };
-      client.captureException(error, { handled: true, server });
-    } catch {
-      // Capture must never break the request pipeline — always forward the error.
-    }
-    next(error);
-  };
-}