@reprova/sdk 0.5.0 → 0.6.0

package/dist/cjs/mongoose.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reprovaMongoosePlugin = reprovaMongoosePlugin;
+exports.instrumentAlreadyCompiledModels = instrumentAlreadyCompiledModels;
+exports.discoverMongooseSchema = discoverMongooseSchema;
+const context_js_1 = require("./context.js");
+const shape_js_1 = require("./shape.js");
+const SELECT_QUERY_OPS = ['find', 'findOne', 'count', 'countDocuments', 'distinct', 'estimatedDocumentCount'];
+const UPDATE_QUERY_OPS = ['updateOne', 'updateMany', 'findOneAndUpdate', 'findOneAndReplace'];
+const DELETE_QUERY_OPS = ['deleteOne', 'deleteMany', 'findOneAndDelete', 'findOneAndRemove', 'remove'];
+// _id(s) from a query/document result, whatever shape it happens to be
+// (array of docs, single doc, null, or a driver-level count/ack object with
+// no docs at all — idsOf simply yields nothing for the last case).
+function idsOf(value) {
+    if (!value)
+        return [];
+    const docs = Array.isArray(value) ? value : [value];
+    const ids = [];
+    for (const d of docs) {
+        const id = d?._id;
+        if (id !== undefined && id !== null)
+            ids.push(String(id));
+    }
+    return ids;
+}
+// updateMany/deleteMany/findOneAndUpdate-family results carry no document
+// ids at all (just {acknowledged, modifiedCount|deletedCount|matchedCount}
+// or a plain number for count()) — this is the bulk-op analog of
+// FootprintQuery.where_shape existing for "no concrete rows, but here's how
+// many and what shape of filter."
+function affectedCountOf(result) {
+    if (typeof result === 'number')
+        return result;
+    const r = result;
+    return r?.modifiedCount ?? r?.deletedCount ?? r?.matchedCount ?? 0;
+}
+// The MongoDB driver connection pool that Mongoose 5.x bundles dispatches a
+// query's response from inside the pooled connection's own socket callback
+// — whose AsyncLocalStorage context is fixed to whatever was ambient when
+// that connection was first used, not the context of whichever query is
+// currently awaiting a result on it. Confirmed empirically: a Mongoose
+// post-hook loses ALS context as soon as a single prior query has run
+// outside a captured request, which every real app does (background jobs,
+// startup queries, connection warmup) — so relying on contextStorage in the
+// post-hook alone silently drops footprints in production, not just in
+// contrived tests. Pre-hooks, by contrast, run synchronously on the
+// caller's own stack before any driver I/O, so they still see the correct
+// context. Capture it there and thread it through to the post-hook via a
+// WeakMap keyed on the query/document instance — Kareem (Mongoose's
+// middleware runner) preserves that same instance as `this` across pre and
+// post for one operation, so the lookup is exact, not a guess.
+const ctxByHost = new WeakMap();
+function captureCtx(host) {
+    const ctx = context_js_1.contextStorage.getStore();
+    if (ctx && host && typeof host === 'object')
+        ctxByHost.set(host, ctx);
+}
+function resolveCtx(host) {
+    return context_js_1.contextStorage.getStore() ?? (host && typeof host === 'object' ? ctxByHost.get(host) : undefined);
+}
+// Find-or-create the (collection, op) entry for this request and fold in
+// whatever this call learned — same merge-by-(table,op) pattern mikroorm.ts
+// uses, extended with a where_shape/count fallback for bulk ops that never
+// expose which specific documents they touched.
+function recordFootprint(ctx, collection, op, pks, affectedCount, whereShape) {
+    if (!ctx || !collection)
+        return;
+    let entry = ctx.footprint.find((f) => f.model === collection && f.op === op);
+    if (!entry) {
+        entry = { model: collection, op, pks: [], count: 0 };
+        ctx.footprint.push(entry);
+    }
+    for (const pk of pks)
+        if (!entry.pks.includes(pk))
+            entry.pks.push(pk);
+    entry.count = entry.pks.length > 0 ? entry.pks.length : Math.max(entry.count, affectedCount);
+    if (whereShape && !entry.where_shape)
+        entry.where_shape = whereShape;
+}
+function recordFromQuery(query, op, result) {
+    const ctx = resolveCtx(query);
+    const collection = query.model?.collection?.collectionName;
+    let whereShape;
+    try {
+        whereShape = query.getFilter ? (0, shape_js_1.shapeArgs)(query.getFilter()) : undefined;
+    }
+    catch {
+        /* filter introspection best-effort */
+    }
+    recordFootprint(ctx, collection, op, idsOf(result), affectedCountOf(result), whereShape);
+}
+// Whether a document was new AT THE TIME save() was called — snapshotted in
+// pre('save') because by the time post('save') runs, Mongoose has already
+// reset doc.isNew to false regardless of which case this was, so isNew
+// alone can't distinguish insert from update from inside the post hook.
+const wasNewByDoc = new WeakMap();
+// Installs Reprova's footprint hooks on a schema. Call BEFORE compiling any
+// model from it — e.g. `mongoose.plugin(reprovaMongoosePlugin)` once,
+// before any `mongoose.model(...)` calls, so every subsequently-compiled
+// model gets it. Registers plain functions, no decorators/classes needed.
+function reprovaMongoosePlugin(schema) {
+    for (const opName of SELECT_QUERY_OPS) {
+        schema.pre(opName, function () {
+            captureCtx(this);
+        });
+        schema.post(opName, function (result) {
+            try {
+                recordFromQuery(this, 'select', result);
+            }
+            catch {
+                /* never break the host query */
+            }
+        });
+    }
+    for (const opName of UPDATE_QUERY_OPS) {
+        schema.pre(opName, function () {
+            captureCtx(this);
+        });
+        schema.post(opName, function (result) {
+            try {
+                recordFromQuery(this, 'update', result);
+            }
+            catch {
+                /* never break the host query */
+            }
+        });
+    }
+    for (const opName of DELETE_QUERY_OPS) {
+        schema.pre(opName, function () {
+            captureCtx(this);
+        });
+        schema.post(opName, function (result) {
+            try {
+                recordFromQuery(this, 'delete', result);
+            }
+            catch {
+                /* never break the host query */
+            }
+        });
+    }
+    schema.pre('save', function () {
+        try {
+            wasNewByDoc.set(this, !!this.isNew);
+        }
+        catch {
+            /* never break the host save */
+        }
+        captureCtx(this);
+    });
+    schema.post('save', function () {
+        try {
+            const wasNew = wasNewByDoc.get(this) ?? !!this.isNew;
+            wasNewByDoc.delete(this);
+            recordFootprint(resolveCtx(this), this.collection?.collectionName, wasNew ? 'insert' : 'update', idsOf(this), 1);
+        }
+        catch {
+            /* never break the host save */
+        }
+    });
+    // insertMany's `this` is the shared Model, not a per-call instance, so it
+    // can't be used as the WeakMap key (concurrent calls would clobber each
+    // other's captured context) — the `docs` array IS per-call and Kareem
+    // passes the same reference to both hooks, so key on that instead.
+    schema.pre('insertMany', function (docs) {
+        captureCtx(docs);
+    });
+    schema.post('insertMany', function (docs) {
+        try {
+            const ids = idsOf(docs);
+            recordFootprint(resolveCtx(docs), this.collection?.collectionName, 'insert', ids, ids.length);
+        }
+        catch {
+            /* never break the host insertMany */
+        }
+    });
+}
+// --- Retroactive instrumentation for already-compiled models -------------
+//
+// `mongoose.plugin(reprovaMongoosePlugin)` only reaches schemas compiled
+// AFTER the call — confirmed empirically that Mongoose bakes its Kareem
+// hook chain in at `mongoose.model(...)` time, so `schema.pre/post` added
+// to an already-compiled model's schema afterward are simply never
+// consulted again. That ordering requirement forces apps whose own
+// bootstrap already compiles a model before Reprova can be wired in (e.g.
+// a multi-file loader architecture that connects Mongoose, compiles
+// models, THEN sets up the rest) to route `Reprova.init()` to wherever
+// runs earliest, rather than wherever's most natural.
+//
+// This covers that case by wrapping each already-compiled model's own
+// query/document methods directly instead of relying on schema hooks — a
+// plain method override works regardless of compile order. It also
+// sidesteps the pooled-connection ALS-loss problem the schema-hook path
+// needs the WeakMap for (see captureCtx/resolveCtx above): the context is
+// captured synchronously into a closure the instant the wrapped method is
+// called, before any driver I/O, so the `.then()` continuation always has
+// the right value on hand regardless of what AsyncLocalStorage does.
+//
+// Idempotent and safe to call repeatedly (e.g. instrumentMongoose() called
+// more than once) — already-patched models are skipped via `patchedModels`.
+const patchedModels = new WeakSet();
+function wrapQueryReturningMethod(model, methodName, op) {
+    const original = model[methodName];
+    if (typeof original !== 'function')
+        return;
+    model[methodName] = function (...args) {
+        const ctx = context_js_1.contextStorage.getStore();
+        const query = original.apply(this, args);
+        if (!query || typeof query.exec !== 'function')
+            return query;
+        const originalExec = query.exec.bind(query);
+        query.exec = (...execArgs) => originalExec(...execArgs).then((result) => {
+            try {
+                const collection = model.collection?.collectionName;
+                let whereShape;
+                try {
+                    whereShape = query.getFilter ? (0, shape_js_1.shapeArgs)(query.getFilter()) : undefined;
+                }
+                catch {
+                    /* filter introspection best-effort */
+                }
+                recordFootprint(ctx, collection, op, idsOf(result), affectedCountOf(result), whereShape);
+            }
+            catch {
+                /* never break the host query */
+            }
+            return result;
+        });
+        return query;
+    };
+}
+function patchCompiledModel(model) {
+    if (patchedModels.has(model))
+        return;
+    patchedModels.add(model);
+    for (const methodName of SELECT_QUERY_OPS)
+        wrapQueryReturningMethod(model, methodName, 'select');
+    for (const methodName of UPDATE_QUERY_OPS)
+        wrapQueryReturningMethod(model, methodName, 'update');
+    for (const methodName of DELETE_QUERY_OPS)
+        wrapQueryReturningMethod(model, methodName, 'delete');
+    const proto = model.prototype;
+    const originalSave = proto?.save;
+    if (proto && typeof originalSave === 'function') {
+        proto.save = function (...args) {
+            const ctx = context_js_1.contextStorage.getStore();
+            const wasNew = !!this.isNew;
+            return originalSave.apply(this, args).then((result) => {
+                try {
+                    recordFootprint(ctx, this.collection?.collectionName, wasNew ? 'insert' : 'update', idsOf(this), 1);
+                }
+                catch {
+                    /* never break the host save */
+                }
+                return result;
+            });
+        };
+    }
+    const originalInsertMany = model.insertMany;
+    if (typeof originalInsertMany === 'function') {
+        model.insertMany = function (...args) {
+            const ctx = context_js_1.contextStorage.getStore();
+            return originalInsertMany.apply(this, args).then((docs) => {
+                try {
+                    const ids = idsOf(docs);
+                    recordFootprint(ctx, model.collection?.collectionName, 'insert', ids, ids.length);
+                }
+                catch {
+                    /* never break the host insertMany */
+                }
+                return docs;
+            });
+        };
+    }
+}
+// Called once from Reprova.instrumentMongoose() alongside the plugin
+// registration above — covers every model that already exists on this
+// mongoose instance at that moment. Any model compiled AFTER this call is
+// still handled by reprovaMongoosePlugin via mongoose.plugin() as before.
+function instrumentAlreadyCompiledModels(mongooseInstance) {
+    let names = [];
+    try {
+        names = mongooseInstance.modelNames();
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        try {
+            patchCompiledModel(mongooseInstance.model(name));
+        }
+        catch {
+            /* one bad model shouldn't block instrumenting the rest */
+        }
+    }
+}
+function discoverMongooseSchema(mongooseInstance) {
+    const models = [];
+    const edges = [];
+    let names = [];
+    try {
+        names = mongooseInstance.modelNames();
+    }
+    catch {
+        return { models, edges };
+    }
+    for (const name of names) {
+        let model;
+        try {
+            model = mongooseInstance.model(name);
+        }
+        catch {
+            continue;
+        }
+        const collection = model.collection?.collectionName;
+        if (!collection)
+            continue;
+        models.push({ model: name, collection });
+        try {
+            model.schema.eachPath((pathName, schemaType) => {
+                // Direct ref: `{ type: Schema.Types.ObjectId, ref: 'X' }`. Array ref:
+                // `[{ type: Schema.Types.ObjectId, ref: 'X' }]` — Mongoose exposes
+                // the array element's own SchemaType (with its own `.options.ref`)
+                // via `.caster` on the array path's SchemaType.
+                const ref = schemaType?.options?.ref ?? schemaType?.caster?.options?.ref;
+                if (ref) {
+                    edges.push({ from_collection: collection, from_field: pathName, to_model: ref, array: !!schemaType?.caster });
+                }
+            });
+        }
+        catch {
+            /* schema introspection best-effort — one bad path shouldn't drop the whole model */
+        }
+    }
+    return { models, edges };
+}

package/dist/cjs/nest.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNestExceptionFilter = createNestExceptionFilter;
+exports.createNestContextInterceptor = createNestContextInterceptor;
+const stack_js_1 = require("./stack.js");
+// Nest's HttpException contract, detected structurally: anything with
+// getStatus() and getResponse() is treated as an intentional HTTP response
+// (a 404, a validation 400, ...) exactly like Nest's own default filter does.
+function isHttpExceptionLike(e) {
+    return (typeof e === 'object' &&
+        e !== null &&
+        typeof e.getStatus === 'function' &&
+        typeof e.getResponse === 'function');
+}
+function toError(exception) {
+    if (exception instanceof Error)
+        return exception;
+    return new Error(typeof exception === 'string' ? exception : JSON.stringify(exception));
+}
+// Express: res.status(n).json(body). Fastify: reply.status(n).send(body).
+// Both expose status(); the payload method is feature-detected. Guarded —
+// an exception filter must never itself throw.
+function sendJson(res, status, body) {
+    try {
+        const r = res;
+        if (typeof r.status !== 'function')
+            return;
+        const chained = r.status(status);
+        if (typeof chained.json === 'function')
+            chained.json(body);
+        else if (typeof chained.send === 'function')
+            chained.send(body);
+    }
+    catch {
+        /* never break the response path from inside the filter */
+    }
+}
+function createNestExceptionFilter(opts = {}) {
+    // Same activation rule as replayErrorHandler: the CLI sets REPROVA_REPLAY=1
+    // when it boots the app for replay; checked once at construction.
+    const replay = process.env.REPROVA_REPLAY === '1';
+    return {
+        catch(exception, host) {
+            const httpEx = isHttpExceptionLike(exception);
+            let status = 500;
+            if (httpEx) {
+                try {
+                    status = exception.getStatus();
+                }
+                catch {
+                    status = 500;
+                }
+            }
+            const res = host.switchToHttp().getResponse();
+            const err = toError(exception);
+            // Replay contract (only for server-side failures — intentional 4xx
+            // responses replay as themselves): emit the structured error the CLI's
+            // verdict comparison expects, via the SAME parseStack used at capture.
+            if (replay && status >= 500) {
+                sendJson(res, 500, {
+                    error: {
+                        type: err.constructor?.name ?? err.name ?? 'Error',
+                        message: err.message,
+                        stack: (0, stack_js_1.parseStack)(err),
+                    },
+                });
+                return;
+            }
+            // Capture server-side failures with the ORIGINAL exception. 4xx
+            // HttpExceptions are intentional control flow, exactly as Nest treats
+            // them — not captured (a silent 500 from elsewhere still gets the 5xx
+            // hook as backstop).
+            if (status >= 500 && opts.capture) {
+                try {
+                    opts.capture(err);
+                }
+                catch {
+                    /* capture must never break the response */
+                }
+            }
+            // Respond the way Nest's own BaseExceptionFilter would have.
+            if (httpEx) {
+                let body;
+                try {
+                    body = exception.getResponse();
+                }
+                catch {
+                    body = { statusCode: status, message: err.message };
+                }
+                sendJson(res, status, typeof body === 'string' ? { statusCode: status, message: body } : body);
+            }
+            else {
+                sendJson(res, 500, { statusCode: 500, message: 'Internal server error' });
+            }
+        },
+    };
+}
+function wrapSubscriptionWithContext(source, runInContext, ctx) {
+    if (!source || typeof source.subscribe !== 'function')
+        return source;
+    const obs = source;
+    const originalSubscribe = obs.subscribe.bind(obs);
+    obs.subscribe = (...args) => runInContext(ctx, () => originalSubscribe(...args));
+    return obs;
+}
+function createNestContextInterceptor(opts) {
+    return {
+        intercept(context, next) {
+            let req;
+            try {
+                req = context.switchToHttp().getRequest();
+            }
+            catch {
+                req = undefined;
+            }
+            let ctx;
+            try {
+                ctx = opts.resolveContext(req);
+            }
+            catch {
+                ctx = undefined;
+            }
+            if (!ctx)
+                return next.handle();
+            // next.handle() itself must be called exactly once — on failure here
+            // there is nothing safe to retry (a second call could re-invoke the
+            // controller method, double-executing whatever it does), so this is
+            // deliberately not wrapped in a try/catch that falls back to a bare
+            // next.handle(). Constructing the Observable is cheap/lazy (no pipe or
+            // controller work happens yet); the actual context wrap lives inside
+            // wrapSubscriptionWithContext, applied to whatever subscribes to it
+            // later, whenever that turns out to be.
+            return wrapSubscriptionWithContext(next.handle(), opts.runInContext, ctx);
+        },
+    };
+}

package/dist/cjs/nextjs.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNextAdapter = createNextAdapter;
+const context_js_1 = require("./context.js");
+const sdk_js_1 = require("./sdk.js");
+const registry_js_1 = require("./registry.js");
+const stack_js_1 = require("./stack.js");
+function toError(value) {
+    if (value instanceof Error)
+        return value;
+    return new Error(typeof value === 'string' ? value : JSON.stringify(value));
+}
+function headersToRecord(headers) {
+    const out = {};
+    headers.forEach((value, key) => {
+        out[key] = value;
+    });
+    return out;
+}
+// Builds a brand-new, self-contained context directly from a Fetch API
+// Request — used when there is no ambient ALS context AND no outer context
+// could be recovered by traceId (instrumentHttp disabled, an edge runtime
+// with no Node http.Server underneath, or any other setup with no "outer"
+// context to begin with). Registered/completed by the caller, same lifecycle
+// runWithContext/runJob already give background work with no HTTP layer at
+// all.
+function contextFromFetchRequest(req) {
+    let path = '/';
+    try {
+        path = new URL(req.url).pathname;
+    }
+    catch {
+        // keep the default
+    }
+    const traceId = req.headers.get('traceparent') ?? (0, stack_js_1.generateTraceId)();
+    return {
+        traceId,
+        capturedAt: new Date(),
+        request: {
+            method: req.method,
+            path,
+            headers: headersToRecord(req.headers),
+            body: '',
+        },
+        footprint: [],
+        outboundCalls: [],
+        businessInvariantHits: [],
+        writeCountDriftHits: [],
+    };
+}
+// The core of wrapRouteHandler's universality: never assumes ambient ALS
+// context survived whatever dispatch mechanism called into this route.
+// Three cases, in order:
+//   1. Ambient context is present — the common case for Pages Router/tRPC,
+//      and for any future Next.js version where App Router propagation
+//      works. Used as-is; nothing to register/complete, that's already
+//      owned by whoever established it.
+//   2. No ambient context, but the request carries the SAME traceparent
+//      value contextFromIncoming wrote onto the raw connection — recovers
+//      the REAL outer context (the one instrumentHttpServers's res 'finish'
+//      handler already closes over for its own http_5xx fallback), so
+//      running the handler inside it and capturing marks that SAME ctx as
+//      captured, suppressing the fallback with zero coordination beyond the
+//      header. This is the case that fixes Next.js App Router: Next
+//      constructs its own Fetch Request rather than reusing the
+//      IncomingMessage, so object-identity recovery (ctxByRequest) can't
+//      work there, but the header survives regardless of what request
+//      object Next builds.
+//   3. Neither — genuinely nothing to recover (instrumentHttp disabled, an
+//      edge runtime). Build a fresh context from the Request itself so a
+//      real capture still happens instead of silently deferring to a
+//      fallback that, in this case, doesn't exist either.
+function resolveRequestContext(req) {
+    const existing = context_js_1.contextStorage.getStore();
+    if (existing)
+        return { ctx: existing, isFresh: false };
+    const traceId = req.headers.get('traceparent');
+    const recovered = traceId ? (0, registry_js_1.findContextByTraceId)(traceId) : undefined;
+    if (recovered)
+        return { ctx: recovered, isFresh: false };
+    const fresh = contextFromFetchRequest(req);
+    (0, registry_js_1.registerContext)(fresh);
+    return { ctx: fresh, isFresh: true };
+}
+// Shared by wrapRouteHandler and withRequestContext: resolves the context
+// once, runs fn() inside it via ALS, and tears down a freshly-built one
+// (never a recovered or already-ambient one — those are owned by whoever
+// created them).
+async function runInResolvedContext(req, fn) {
+    const { ctx, isFresh } = resolveRequestContext(req);
+    try {
+        return await context_js_1.contextStorage.run(ctx, () => fn(ctx));
+    }
+    finally {
+        if (isFresh)
+            (0, registry_js_1.completeContext)(ctx);
+    }
+}
+function createNextAdapter(opts) {
+    const { prisma, dmmf, ...reprovaOpts } = opts;
+    const sdk = sdk_js_1.Reprova.init(reprovaOpts);
+    // Not caught here deliberately: a Prisma instrumentation failure is a real
+    // setup bug (bad dmmf, a client shape instrumentPrisma doesn't recognize),
+    // not something to silently swallow — every ensureInit() caller sees the
+    // same rejection instrumentPrisma itself produced, same as the original
+    // cal.diy wiring this replaces (`await reprovaSdk.instrumentPrisma(...)`,
+    // no try/catch).
+    const initPromise = prisma !== undefined ? sdk.instrumentPrisma(prisma, { dmmf }) : Promise.resolve();
+    function ensureInit() {
+        return initPromise;
+    }
+    // Used by wrapApiHandler and trpcMiddleware — both reliably see the
+    // ambient context established further up the stack (Pages Router's
+    // apiResolver mutates the SAME req object instrumentHttpServers already
+    // saw; tRPC procedures run inside whatever context wrapped the HTTP
+    // handler that dispatches them). Confirmed live: only App Router's own
+    // internal dispatch loses the ALS store (see wrapRouteHandler below for
+    // the fix) — Pages Router and tRPC carry it through fine, so they don't
+    // need the recovery dance.
+    function captureUnhandled(err) {
+        const ctx = context_js_1.contextStorage.getStore();
+        if (!ctx || ctx.captured)
+            return;
+        sdk.capture('unhandled_exception', toError(err), ctx);
+    }
+    return {
+        ensureInit,
+        captureError(err) {
+            const ctx = context_js_1.contextStorage.getStore();
+            if (!ctx || ctx.captured)
+                return;
+            sdk.captureError(toError(err));
+        },
+        wrapRouteHandler(handler) {
+            return (async (req, ...rest) => {
+                await ensureInit();
+                // Establishing ALS directly around this call — rather than
+                // depending on whatever context Next's own dispatch may or may not
+                // have carried through to get here — is what makes this work
+                // regardless of Next.js version, App Router internals, or
+                // Turbopack vs. webpack: there is no dispatch layer left between
+                // this contextStorage.run() and the handler for anything to lose.
+                return runInResolvedContext(req, async (ctx) => {
+                    try {
+                        return await handler(req, ...rest);
+                    }
+                    catch (err) {
+                        if (!ctx.captured)
+                            sdk.capture('unhandled_exception', toError(err), ctx);
+                        throw err;
+                    }
+                });
+            });
+        },
+        async withRequestContext(req, fn) {
+            await ensureInit();
+            return runInResolvedContext(req, () => Promise.resolve(fn()));
+        },
+        wrapApiHandler(handler) {
+            return async (req, res) => {
+                await ensureInit();
+                try {
+                    await handler(req, res);
+                }
+                catch (err) {
+                    captureUnhandled(err);
+                    throw err;
+                }
+            };
+        },
+        trpcMiddleware: async ({ next }) => {
+            await ensureInit();
+            const result = await next();
+            if (!result.ok && result.error?.code === 'INTERNAL_SERVER_ERROR') {
+                captureUnhandled(result.error.cause ?? result.error);
+            }
+            return result;
+        },
+    };
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}