@reproapp/node-sdk 0.0.1 → 0.0.2

package/src/integrations/sendgrid.ts

@@ -0,0 +1,184 @@
+// repro-node/src/integrations/sendgrid.ts
+import { AsyncLocalStorage } from 'async_hooks';
+
+type Ctx = { sid?: string; aid?: string };
+const als = new AsyncLocalStorage<Ctx>();
+export const getCtx = () => als.getStore() || {};
+
+// If you already export als/getCtx from repro-node, reuse that instead of re-declaring.
+
+async function post(
+    cfg: { appId: string; appSecret: string; appName?: string; apiBase?: string },
+    sessionId: string,
+    body: any,
+) {
+    try {
+        const envBase = typeof process !== 'undefined' ? (process as any)?.env?.REPRO_API_BASE : undefined;
+        const legacyBase = (cfg as any)?.apiBase;
+        const apiBase = String(envBase || legacyBase || 'https://oozy-loreta-gully.ngrok-free.dev').replace(/\/+$/, '');
+        await fetch(`${apiBase}/v1/sessions/${sessionId}/backend`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-App-Id': cfg.appId,
+                'X-App-Secret': cfg.appSecret,
+                ...(cfg.appName ? { 'X-App-Name': cfg.appName } : {}),
+            },
+            body: JSON.stringify(body),
+        });
+    } catch { /* swallow */ }
+}
+
+export type SendgridPatchConfig = {
+    appId: string;
+    appSecret: string;
+    appName?: string;
+    // Optional: provide a function to resolve sid/aid if AsyncLocalStorage is not set
+    resolveContext?: () => { sid?: string; aid?: string } | undefined;
+};
+
+/**
+ * Patch @sendgrid/mail's send() and sendMultiple() to capture outbound email.
+ * Idempotent. No behavior change for the app.
+ */
+export function patchSendgridMail(cfg: SendgridPatchConfig) {
+    let sgMail: any;
+    try { sgMail = require('@sendgrid/mail'); } catch { return; } // not installed → no-op
+
+    if (!sgMail || (sgMail as any).__repro_patched) return;
+    (sgMail as any).__repro_patched = true;
+
+    const origSend = sgMail.send?.bind(sgMail);
+    const origSendMultiple = sgMail.sendMultiple?.bind(sgMail);
+
+    if (origSend) {
+        sgMail.send = async function patchedSend(msg: any, isMultiple?: boolean) {
+            const startedAt = Date.now();
+            let statusCode: number | undefined;
+            let headers: Record<string, any> | undefined;
+
+            try {
+                const res = await origSend(msg, isMultiple);
+                // sendgrid returns [response] as array in v7.x
+                const r = Array.isArray(res) ? res[0] : res;
+                statusCode = r?.statusCode ?? r?.status ?? undefined;
+                headers = r?.headers ?? undefined;
+                return res;
+            } finally {
+                fireCapture('send', msg, startedAt, statusCode, headers);
+            }
+        };
+    }
+
+    if (origSendMultiple) {
+        sgMail.sendMultiple = async function patchedSendMultiple(msg: any) {
+            const startedAt = Date.now();
+            let statusCode: number | undefined;
+            let headers: Record<string, any> | undefined;
+
+            try {
+                const res = await origSendMultiple(msg);
+                const r = Array.isArray(res) ? res[0] : res;
+                statusCode = r?.statusCode ?? r?.status ?? undefined;
+                headers = r?.headers ?? undefined;
+                return res;
+            } finally {
+                fireCapture('sendMultiple', msg, startedAt, statusCode, headers);
+            }
+        };
+    }
+
+    function fireCapture(kind: 'send' | 'sendMultiple', rawMsg: any, t0: number, statusCode?: number, headers?: any) {
+        const ctx = getCtx();
+        const sid = ctx.sid ?? cfg.resolveContext?.()?.sid;
+        const aid = ctx.aid ?? cfg.resolveContext?.()?.aid;
+        if (!sid) return; // no active session → skip
+
+        const norm = normalizeSendgridMessage(rawMsg);
+        const entry = {
+            actionId: aid ?? null,
+            email: {
+                provider: 'sendgrid',
+                kind,
+                to: norm.to,
+                cc: norm.cc,
+                bcc: norm.bcc,
+                from: norm.from,
+                subject: norm.subject,
+                text: norm.text,                 // you said privacy later → include now
+                html: norm.html,                 // idem
+                templateId: norm.templateId,
+                dynamicTemplateData: norm.dynamicTemplateData,
+                categories: norm.categories,
+                customArgs: norm.customArgs,
+                attachmentsMeta: norm.attachmentsMeta, // safe metadata only
+                statusCode,
+                durMs: Date.now() - t0,
+                headers: headers ?? {},
+            },
+            t: Date.now(),
+        };
+
+        post(cfg, sid, { entries: [entry] });
+    }
+
+    function normalizeAddress(a: any): { email: string; name?: string } | null {
+        if (!a) return null;
+        if (typeof a === 'string') return { email: a };
+        if (typeof a === 'object' && a.email) return { email: String(a.email), name: a.name ? String(a.name) : undefined };
+        return null;
+    }
+
+    function normalizeAddressList(v: any): Array<{ email: string; name?: string }> | undefined {
+        if (!v) return undefined;
+        const arr = Array.isArray(v) ? v : [v];
+        const out = arr.map(normalizeAddress).filter(Boolean) as Array<{ email: string; name?: string }>;
+        return out.length ? out : undefined;
+    }
+
+    function normalizeSendgridMessage(msg: any) {
+        // sendgrid supports "personalizations" & top-level fields; we’ll flatten the common pieces
+        const base = {
+            from: normalizeAddress(msg?.from) ?? undefined,
+            to: normalizeAddressList(msg?.to),
+            cc: normalizeAddressList(msg?.cc),
+            bcc: normalizeAddressList(msg?.bcc),
+            subject: msg?.subject ? String(msg.subject) : undefined,
+            text: typeof msg?.text === 'string' ? msg.text : undefined,
+            html: typeof msg?.html === 'string' ? msg.html : undefined,
+            templateId: msg?.templateId ? String(msg.templateId) : undefined,
+            dynamicTemplateData: msg?.dynamic_template_data ?? msg?.dynamicTemplateData ?? undefined,
+            categories: Array.isArray(msg?.categories) ? msg.categories.map(String) : undefined,
+            customArgs: msg?.customArgs ?? msg?.custom_args ?? undefined,
+            attachmentsMeta: Array.isArray(msg?.attachments)
+                ? msg.attachments.map((a: any) => ({
+                    filename: a?.filename ? String(a.filename) : undefined,
+                    type: a?.type ? String(a.type) : undefined,
+                    size: a?.content ? byteLen(a.content) : undefined, // base64 or string → approximate size
+                }))
+                : undefined,
+        };
+
+        // If personalizations exist, pull the FIRST one as representative (keeps MVP simple)
+        const p0 = Array.isArray(msg?.personalizations) ? msg.personalizations[0] : undefined;
+        if (p0) {
+            base.to = normalizeAddressList(p0.to) ?? base.to;
+            base.cc = normalizeAddressList(p0.cc) ?? base.cc;
+            base.bcc = normalizeAddressList(p0.bcc) ?? base.bcc;
+            if (!base.subject && p0.subject) base.subject = String(p0.subject);
+            // template data can also live inside personalization
+            if (!base.dynamicTemplateData && p0.dynamic_template_data) base.dynamicTemplateData = p0.dynamic_template_data;
+            if (!base.customArgs && p0.custom_args) base.customArgs = p0.custom_args;
+        }
+
+        return base;
+    }
+
+    function byteLen(content: any): number | undefined {
+        try {
+            if (typeof content === 'string') return Buffer.byteLength(content, 'utf8');
+            if (content && typeof content === 'object' && 'length' in content) return Number((content as any).length);
+        } catch {}
+        return undefined;
+    }
+}

package/tracer/cjs-hook.js

@@ -0,0 +1,281 @@
+// cjs-hook.js
+const fs = require('node:fs');
+const Module = require('node:module');
+const path = require('node:path');
+const babel = require('@babel/core');
+const makeWrap = require('./wrap-plugin');
+const { TraceMap, originalPositionFor } = require('@jridgewell/trace-mapping');
+const { SYM_SRC_FILE, SYM_IS_APP, SYM_BODY_TRACED } = require('./runtime');
+
+const CWD = process.cwd().replace(/\\/g, '/');
+const escapeRx = s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+// app file check (your existing logic)
+function isAppFile(filename) {
+    const f = String(filename || '').replace(/\\/g, '/');
+    return f.startsWith(CWD + '/') && !f.includes('/node_modules/');
+}
+
+function toPosix(file) {
+    return String(file || '').replace(/\\/g, '/');
+}
+
+function tagExports(value, filename, seen = new WeakSet(), depth = 0, instrumented = false) {
+    if (value == null) return;
+    const ty = typeof value;
+    if (ty !== 'object' && ty !== 'function') return;
+    if (seen.has(value)) return;
+    seen.add(value);
+
+    const isApp = isAppFile(filename);
+
+    if (typeof value === 'function') {
+        try {
+            if (!value[SYM_SRC_FILE]) {
+                Object.defineProperty(value, SYM_SRC_FILE, { value: filename, configurable: true });
+            }
+            if (value[SYM_IS_APP] !== isApp) {
+                Object.defineProperty(value, SYM_IS_APP, { value: isApp, configurable: true });
+            }
+            if (instrumented && value.__repro_instrumented !== true) {
+                Object.defineProperty(value, '__repro_instrumented', { value: true, configurable: true });
+            }
+            if (instrumented && value[SYM_BODY_TRACED] !== true) {
+                Object.defineProperty(value, SYM_BODY_TRACED, { value: true, configurable: true });
+            }
+        } catch {}
+        const proto = value.prototype;
+        if (proto && typeof proto === 'object') {
+            for (const k of Object.getOwnPropertyNames(proto)) {
+                if (k === 'constructor') continue;
+                const d = Object.getOwnPropertyDescriptor(proto, k);
+                if (!d) continue;
+                if (typeof d.value === 'function') tagExports(d.value, filename, seen, depth + 1, instrumented);
+                // also tag accessors
+                if (typeof d.get === 'function') tagExports(d.get, filename, seen, depth + 1, instrumented);
+                if (typeof d.set === 'function') tagExports(d.set, filename, seen, depth + 1, instrumented);
+            }
+        }
+    }
+
+    if (typeof value === 'object' && depth < 4) {
+        for (const k of Object.getOwnPropertyNames(value)) {
+            const d = Object.getOwnPropertyDescriptor(value, k);
+            if (!d) continue;
+
+            if ('value' in d) tagExports(d.value, filename, seen, depth + 1, instrumented);
+
+            if (typeof d.get === 'function') {
+                tagExports(d.get, filename, seen, depth + 1, instrumented);
+                try { tagExports(value[k], filename, seen, depth + 1, instrumented); } catch {}
+            }
+            if (typeof d.set === 'function') {
+                tagExports(d.set, filename, seen, depth + 1, instrumented);
+            }
+        }
+    }
+}
+
+function installCJS({ include, exclude, parserPlugins } = {}) {
+    // default include = project dir; exclude node_modules
+    const inc = Array.isArray(include) && include.length
+        ? include
+        : [ new RegExp('^' + escapeRx(CWD + '/')) ];
+    const exc = Array.isArray(exclude) ? exclude : [];
+
+    const shouldHandle = (f) => {
+        const s = String(f || '').replace(/\\/g, '/');
+        if (exc.some(rx => rx.test(s))) return false;
+        return inc.some(rx => rx.test(s));
+    };
+
+    // ---- Global hook: intercept *all* compiles, regardless of how .ts was compiled ----
+    const origCompile = Module.prototype._compile;
+    const transformedFiles = new Set();
+    Module.prototype._compile = function patchedCompile(code, filename) {
+        let out = code;
+        let metaFilename = filename;
+        let mapOriginalPosition = null;
+        let wasInstrumented = false;
+        try {
+            if (transformedFiles.has(filename)) {
+                // Already transformed once; avoid double-transforming code that may already include __repro_call wrappers.
+                out = code;
+            } else if (shouldHandle(filename) && isAppFile(filename)) {
+                try { process.stderr.write(`[trace-debug] compile: ${filename}\n`); } catch {}
+                const sourceInfo = getSourceInfo(code, filename);
+                if (sourceInfo?.metaFilename) {
+                    metaFilename = sourceInfo.metaFilename;
+                }
+                if (typeof sourceInfo?.mapOriginalPosition === 'function') {
+                    mapOriginalPosition = sourceInfo.mapOriginalPosition;
+                }
+                // Transform the already-compiled JS (keeps Nest’s decorator metadata intact)
+                const res = babel.transformSync(code, {
+                    filename,
+                    sourceType: 'unambiguous',
+                    retainLines: true,
+                    sourceMaps: 'inline',
+                    parserOpts: {
+                        sourceType: 'unambiguous',
+                        // We’re parsing JS here; TS was compiled by ts-node/Nest.
+                        plugins: parserPlugins || [
+                            'jsx', 'classProperties', 'classPrivateProperties',
+                            'classPrivateMethods', 'dynamicImport', 'topLevelAwait',
+                            'optionalChaining', 'nullishCoalescingOperator',
+                        ],
+                    },
+                    // only the wrap plugin; do NOT run TS transform here
+                    plugins: [
+                        [ makeWrap(metaFilename, {
+                            mode: 'all',
+                            wrapGettersSetters: false,
+                            skipAnonymous: false,
+                            mapOriginalPosition,
+                        }) ],
+                    ],
+                    compact: false,
+                    comments: true,
+                });
+                out = res?.code || code;
+                wasInstrumented = !!res?.code;
+                transformedFiles.add(filename);
+            }
+        } catch (err) {
+            out = code; // never break the app if transform fails
+            try { process.stderr.write(`[trace-debug] compile error: ${filename} :: ${err?.message || err}\n`); } catch {}
+        }
+
+        const ret = origCompile.call(this, out, filename);
+
+        // Tag exports for origin detection
+        try { tagExports(this.exports, metaFilename, new WeakSet(), 0, wasInstrumented); } catch {}
+        try { this.__repro_wrapped = true; } catch {}
+
+        return ret;
+    };
+
+    // keep your load wrapper to tag modules loaded in other ways too
+    const _resolveFilename = Module._resolveFilename;
+    const _load = Module._load;
+    Module._load = function patchedLoad(request, parent, isMain) {
+        const filename = (() => {
+            try { return _resolveFilename.call(Module, request, parent, isMain); }
+            catch { return String(request); } // e.g., 'node:fs'
+        })();
+        const exp = _load.apply(this, arguments);
+        try { tagExports(exp, filename); } catch {}
+        return exp;
+    };
+}
+
+function getSourceInfo(code, filename) {
+    try {
+        const map = loadSourceMap(code, filename);
+        if (!map) return null;
+
+        const mapFile = map.__mapFile || filename;
+        const { sources = [], sourceRoot } = map;
+        const resolvedSourceRoot = sourceRoot
+            ? resolveSourcePath(sourceRoot, mapFile)
+            : '';
+
+        let metaFilename = null;
+        for (const src of sources) {
+            if (!src) continue;
+            const abs = resolveSourcePath(src, mapFile, resolvedSourceRoot);
+            if (!abs) continue;
+            metaFilename = toPosix(abs);
+            break;
+        }
+
+        const mapper = makeOriginalPositionMapper(map, mapFile, resolvedSourceRoot);
+
+        return {
+            metaFilename,
+            mapOriginalPosition: mapper,
+        };
+    } catch {}
+    return null;
+}
+
+function makeOriginalPositionMapper(map, mapFile, resolvedSourceRoot) {
+    try {
+        const traceMap = new TraceMap(map);
+        return (line, column = 0) => {
+            if (line == null) return null;
+            try {
+                const original = originalPositionFor(traceMap, { line, column });
+                if (!original || original.line == null) return null;
+
+                const file = original.source
+                    ? toPosix(resolveSourcePath(original.source, mapFile, resolvedSourceRoot))
+                    : null;
+
+                return {
+                    line: original.line,
+                    column: original.column ?? 0,
+                    file,
+                };
+            } catch {
+                return null;
+            }
+        };
+    } catch {
+        return null;
+    }
+}
+
+function resolveSourcePath(sourcePath, relativeTo, rootOverride) {
+    try {
+        const baseDir = path.dirname(relativeTo);
+        const combined = rootOverride
+            ? path.resolve(rootOverride, sourcePath)
+            : path.resolve(baseDir, sourcePath);
+        return combined;
+    } catch {
+        return null;
+    }
+}
+
+function loadSourceMap(code, filename) {
+    const match = /\/\/[#@]\s*sourceMappingURL=([^\s]+)/.exec(code);
+    if (!match) return null;
+
+    const url = match[1].trim();
+    if (!url) return null;
+
+    if (url.startsWith('data:')) {
+        return parseDataUrl(url);
+    }
+
+    const mapPath = path.resolve(path.dirname(filename), url);
+    try {
+        const text = fs.readFileSync(mapPath, 'utf8');
+        const json = JSON.parse(text);
+        Object.defineProperty(json, '__mapFile', { value: mapPath });
+        return json;
+    } catch {
+        return null;
+    }
+}
+
+function parseDataUrl(url) {
+    const comma = url.indexOf(',');
+    if (comma < 0) return null;
+
+    const meta = url.slice(5, comma);
+    const data = url.slice(comma + 1);
+
+    try {
+        if (/;base64/i.test(meta)) {
+            const buf = Buffer.from(data, 'base64');
+            return JSON.parse(buf.toString('utf8'));
+        }
+        return JSON.parse(decodeURIComponent(data));
+    } catch {
+        return null;
+    }
+}
+
+module.exports = { installCJS };

package/tracer/dep-hook.js

@@ -0,0 +1,142 @@
+// dep-hook.js
+'use strict';
+
+const path = require('node:path');
+const shimmer = require('shimmer');
+
+const {
+    SYM_SKIP_WRAP
+} = require('./runtime');
+
+// ---- config / guards ----
+const CWD = process.cwd().replace(/\\/g, '/');
+const isOurFile = (f) => f && f.replace(/\\/g,'/').includes('/omnitrace/') || f.includes('/repro/');
+const isInNodeModules = (f) => f && f.replace(/\\/g,'/').includes('/node_modules/');
+
+const SKIP_METHOD_NAMES = new Set([
+    // thenables + common promise-ish
+    'then','catch','finally',
+    // mongoose query/aggregate “execute” hooks — we log via schema middleware
+    'exec',
+    // avoid patching Node’s Symbol-based internals
+    Symbol.toStringTag
+]);
+
+// Don’t double-wrap
+function alreadyWrapped(fn) { return !!(fn && fn.__repro_wrapped); }
+function markWrapped(fn) { try { Object.defineProperty(fn, '__repro_wrapped', { value: true }); } catch {} }
+
+// our call bridge -> uses your global helper, preserves return value identity
+function wrapFunction(original, label, file, line) {
+    if (typeof original !== 'function') return original;
+    if (alreadyWrapped(original)) return original;
+
+    const wrapped = function reproWrapped() {
+        // Use the call-site shim to classify app/dep and to safely handle thenables
+        return global.__repro_call
+            ? global.__repro_call(original, this, Array.from(arguments), file, line, label || original.name || '', false)
+            : original.apply(this, arguments);
+    };
+
+    // copy a few common props (name/length are non-writable; don’t force)
+    try { wrapped[SYM_SKIP_WRAP] = true; } catch {}
+    try { Object.defineProperty(wrapped, '__repro_instrumented', { value: true, configurable: true }); } catch {}
+    markWrapped(wrapped);
+    return wrapped;
+}
+
+function wrapObjectMethods(obj, file) {
+    const seen = new WeakSet();
+    const maxDepth = 4;
+
+    const visit = (target, depth = 0) => {
+        if (!target || (typeof target !== 'object' && typeof target !== 'function')) return;
+        if (seen.has(target)) return;
+        if (depth > maxDepth) return;
+        seen.add(target);
+
+        // own props
+        for (const k of Object.getOwnPropertyNames(target)) {
+            const d = Object.getOwnPropertyDescriptor(target, k);
+            if (!d) continue;
+            if (d.get || d.set) continue; // never wrap accessors
+            if (SKIP_METHOD_NAMES.has(k)) continue;
+
+            if (typeof d.value === 'function') {
+                const v = d.value;
+                if (!alreadyWrapped(v)) {
+                    const w = wrapFunction(v, String(k), file, 0);
+                    try { shimmer.wrap(target, k, () => w); } catch {
+                        try { target[k] = w; } catch {}
+                    }
+                }
+                continue;
+            }
+
+            if (d.value && (typeof d.value === 'object' || typeof d.value === 'function')) {
+                visit(d.value, depth + 1);
+            }
+        }
+
+        // class prototype methods (walk depth once)
+        const proto = Object.getPrototypeOf(target);
+        if (proto && proto !== Object.prototype) {
+            visit(proto, depth + 1);
+        }
+    };
+
+    visit(obj, 0);
+    return obj;
+}
+
+function shouldInstrument(filename, moduleName) {
+    const f = String(filename || '').replace(/\\/g,'/');
+
+    if (!f) return false;
+    if (isOurFile(f)) return false;                        // never instrument tracer itself
+    if (f.includes('/@babel/')) return false;              // avoid babel internals
+    if (!isInNodeModules(f) && !f.startsWith(CWD + '/')) { // odd cases
+        return false;
+    }
+    return true;
+}
+
+function instrumentExports(exports, filename, moduleName) {
+    if (!shouldInstrument(filename, moduleName)) return exports;
+
+    // Avoid breaking common patterns:
+    // - Don’t mutate Mongoose core types (Query/Aggregate) — you already log via schema hooks
+    try {
+        if (moduleName === 'mongoose' || /[\\/]mongoose[\\/]/.test(filename)) {
+            // wrap top-level exported functions only; skip prototype types
+            if (exports && typeof exports === 'object') {
+                for (const k of Object.getOwnPropertyNames(exports)) {
+                    const d = Object.getOwnPropertyDescriptor(exports, k);
+                    if (!d || d.get || d.set) continue;
+                    if (typeof d.value === 'function' && !SKIP_METHOD_NAMES.has(k)) {
+                        const w = wrapFunction(d.value, `${moduleName}.${k}`, filename, 0);
+                        try { shimmer.wrap(exports, k, () => w); } catch {}
+                    }
+                }
+            }
+            return exports;
+        }
+    } catch {}
+
+    // Generic: recursively wrap functions on object exports
+    try {
+        if (typeof exports === 'function') {
+            const wrapped = wrapFunction(exports, moduleName || path.basename(filename), filename, 0);
+            try { wrapObjectMethods(wrapped.prototype, filename); } catch {}
+            return wrapped;
+        }
+        if (exports && typeof exports === 'object') {
+            const wrappedObj = wrapObjectMethods(exports, filename);
+            return wrappedObj;
+        }
+    } catch {}
+
+    return exports;
+}
+
+module.exports = { instrumentExports };

package/tracer/esm-loader.mjs

@@ -0,0 +1,46 @@
+// esm-loader.mjs
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import * as babel from '@babel/core';
+import tsPlugin from '@babel/plugin-transform-typescript';
+import makeWrap from './wrap-plugin.js';
+
+const parserPlugins = [
+    'jsx',
+    ['decorators', { version: 'legacy' }], // adjust per your stack
+    'classProperties','classPrivateProperties','classPrivateMethods',
+    'dynamicImport','topLevelAwait','typescript'
+];
+
+// naive include/exclude based on CWD by default
+const CWD = process.cwd().replace(/\\/g,'/');
+const include = [ new RegExp('^' + CWD.replace(/[.*+?^${}()|[\\]\\\\]/g,'\\$&') + '/') ];
+const exclude = [ /node_modules[\\/]/ ];
+
+export async function resolve(specifier, context, next) {
+    const r = await next(specifier, context);
+    return r; // default resolution
+}
+
+export async function load(url, context, next) {
+    const r = await next(url, context);
+    if (r.format !== 'module' && r.format !== 'commonjs') return r;
+
+    const filename = url.startsWith('file:') ? fileURLToPath(url) : null;
+    if (!filename) return r;
+
+    const s = filename.replace(/\\/g,'/');
+    if (exclude.some(rx => rx.test(s)) || !include.some(rx => rx.test(s))) return r;
+
+    const code = await readFile(filename, 'utf8');
+    const out = babel.transformSync(code, {
+        filename,
+        sourceType: 'unambiguous',
+        retainLines: true,
+        parserOpts: { sourceType:'unambiguous', plugins: parserPlugins },
+        plugins: [[ makeWrap(filename) ], [ tsPlugin, { allowDeclareFields:true } ]],
+        sourceMaps: 'inline',
+    })?.code || code;
+
+    return { format: r.format, source: out };
+}