@lensmcp/node-instrumentation 1.0.0

package/lib/require-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-hook.d.ts","sourceRoot":"","sources":["../../src/lib/require-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,aAAa,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,CAAC;AAanE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CA2BxE"}

package/lib/require-hook.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * CJS require hook: the cluster's dev webpack config externalizes every real
+ * node_modules package (`commonjs <request>`), so at pod runtime `pg`,
+ * `ioredis`, `bullmq` and `@nestjs/core` arrive through `Module._load`. We
+ * intercept the EXACT package names and mutate their exports IN PLACE
+ * (prototype/static patches, never proxies) — ESM `import` of the same CJS
+ * package yields the same exports object, so both module systems observe the
+ * patched behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installRequireHook = installRequireHook;
+const tapped = new Set();
+function runTap(name, tap, exportsObject) {
+    try {
+        const installed = tap(exportsObject);
+        if (installed !== false)
+            tapped.add(name);
+    }
+    catch {
+        tapped.add(name); // a THROWING tap must not retry forever
+    }
+}
+function installRequireHook(taps) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Module = require('node:module');
+    const origLoad = Module._load;
+    Module._load = function (request, ...rest) {
+        const exportsObject = origLoad.call(this, request, ...rest);
+        const tap = taps[request];
+        if (tap && !tapped.has(request))
+            runTap(request, tap, exportsObject);
+        return exportsObject;
+    };
+    // Anything already loaded before the hook installed gets tapped from cache.
+    for (const name of Object.keys(taps)) {
+        if (tapped.has(name))
+            continue;
+        const tap = taps[name];
+        if (!tap)
+            continue;
+        try {
+            const resolved = require.resolve(name);
+            const cached = require.cache[resolved];
+            if (cached)
+                runTap(name, tap, cached.exports);
+        }
+        catch {
+            /* package not installed in this workspace — fine */
+        }
+    }
+}

package/lib/tap-bullmq.d.ts

@@ -0,0 +1,2 @@
+export declare function bullmqTap(exportsObject: unknown): boolean;
+//# sourceMappingURL=tap-bullmq.d.ts.map

package/lib/tap-bullmq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-bullmq.d.ts","sourceRoot":"","sources":["../../src/lib/tap-bullmq.ts"],"names":[],"mappings":"AAoDA,wBAAgB,SAAS,CAAC,aAAa,EAAE,OAAO,GAAG,OAAO,CAczD"}

package/lib/tap-bullmq.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bullmqTap = bullmqTap;
+/**
+ * BullMQ tap (source `queue`): the queue node on the canvas, zero-touch.
+ *
+ * Everything hooks PROTOTYPES — bullmq's module exports are TypeScript
+ * getter-only bindings (`__createBinding`, non-configurable), so replacing
+ * `exports.Worker` with a subclass silently fails. Prototype mutation is the
+ * seam that actually works:
+ *  - `Queue.prototype.add` → kind `queue-enqueued` (+ ensures the state
+ *    publisher using THIS queue instance — no extra connection)
+ *  - `Worker.prototype.emit` → observes the worker's own lifecycle events:
+ *    `active`/`completed`/`failed` → kinds `queue-active/completed/failed`,
+ *    and on first sight of a worker ensures the state publisher
+ *  - per queue, a 2s-when-changed snapshot → kind `queue-state` with `counts`
+ *    + the 8 most recent jobs ({id, name, state, to?, timestamp}) — the exact
+ *    contract the dashboard's queue panel renders.
+ */
+const emit_1 = require("./emit");
+const flow_context_1 = require("./flow-context");
+function jobFlow(job) {
+    const stamp = job?.opts?.['__lensmcpFlow'];
+    return stamp && typeof stamp === 'object' ? stamp : undefined;
+}
+/** The worker leg's own requestId — its block in the flow, distinct from the
+ *  HTTP request that enqueued it. */
+const jobLegId = (queue, job) => `job:${queue}#${job?.id ?? '?'}`;
+const publishers = new Map();
+function bullmqTap(exportsObject) {
+    const mod = exportsObject;
+    // Partial exports mid-load (circular require) — let the hook retry later.
+    if (typeof mod?.['Queue'] !== 'function' || typeof mod?.['Worker'] !== 'function')
+        return false;
+    try {
+        tapQueueAdd(mod);
+    }
+    catch { /* shape drift — skip */ }
+    try {
+        tapWorkerEmit(mod);
+    }
+    catch { /* shape drift — skip */ }
+    try {
+        tapWorkerProcess(mod);
+    }
+    catch { /* shape drift — skip */ }
+    return true;
+}
+/**
+ * The worker's PROCESSING leg: wrap `Worker.prototype.callProcessJob` so the
+ * job runs inside the flow context stamped at enqueue — every tap the
+ * processor hits (an egress call, a db write) inherits the flow — and emit a
+ * `queue-process` span that anchors the worker leg in the trace.
+ */
+function tapWorkerProcess(mod) {
+    const Worker = mod['Worker'];
+    const proto = Worker?.prototype;
+    const orig = proto?.['callProcessJob'];
+    if (!proto || typeof orig !== 'function' || orig.__lensmcp)
+        return;
+    const wrapped = async function (job, ...rest) {
+        const stamp = jobFlow(job);
+        if (!stamp?.flowId)
+            return orig.call(this, job, ...rest);
+        const queueName = String(this?.name ?? job?.queueName ?? 'queue');
+        const legId = jobLegId(queueName, job);
+        const t0 = Date.now();
+        const fctx = { flowId: stamp.flowId, requestId: legId };
+        return (0, flow_context_1.runInFlowContext)(fctx, async () => {
+            try {
+                const result = await orig.call(this, job, ...rest);
+                (0, emit_1.lensEmit)('queue', 'info', `process ${job?.name}#${job?.id} (${Date.now() - t0}ms)`, {
+                    queue: queueName, kind: 'queue-process', job: job?.name, jobId: job?.id,
+                    startedAt: t0, durationMs: Date.now() - t0, status: 'ok',
+                }, `queue:${queueName}`, fctx);
+                return result;
+            }
+            catch (err) {
+                (0, emit_1.lensEmit)('queue', 'error', `process ${job?.name}#${job?.id} failed (${Date.now() - t0}ms)`, {
+                    queue: queueName, kind: 'queue-process', job: job?.name, jobId: job?.id,
+                    startedAt: t0, durationMs: Date.now() - t0, status: 'error',
+                    error: String(err?.message ?? err),
+                }, `queue:${queueName}`, fctx);
+                throw err;
+            }
+        });
+    };
+    wrapped.__lensmcp = true;
+    proto['callProcessJob'] = wrapped;
+}
+function tapQueueAdd(mod) {
+    const Queue = mod['Queue'];
+    const proto = Queue?.prototype;
+    const orig = proto?.['add'];
+    if (!proto || typeof orig !== 'function' || orig.__lensmcp)
+        return;
+    const wrapped = async function (name, ...rest) {
+        const t0 = Date.now();
+        const ctx = (0, flow_context_1.flowContext)(); // the enqueue happens inside the request's scope
+        if (ctx?.flowId) {
+            // Ride the flow on the job itself (opts survive the redis round trip),
+            // so the WORKER's processing joins this flow as its own leg.
+            const opts = (rest[1] ?? {});
+            rest[1] = { ...opts, __lensmcpFlow: { flowId: ctx.flowId, ...(ctx.requestId ? { originRequestId: ctx.requestId } : {}) } };
+        }
+        const job = await orig.call(this, name, ...rest);
+        try {
+            const queueName = String(this?.name ?? 'queue');
+            const data = rest[0];
+            let dataPreview;
+            try {
+                const s = JSON.stringify(data);
+                dataPreview = s && s !== 'undefined' ? (s.length > 300 ? s.slice(0, 299) + '…' : s) : undefined;
+            }
+            catch { /* unserializable payload */ }
+            (0, emit_1.lensEmit)('queue', 'info', `enqueued ${name}#${job?.id} → ${queueName}`, {
+                queue: queueName, kind: 'queue-enqueued', job: name, jobId: job?.id,
+                ...(dataPreview ? { data: dataPreview } : {}),
+                startedAt: t0, durationMs: Date.now() - t0,
+            }, `queue:${queueName}`, ctx);
+            ensureStatePublisher(queueName, this); // producer side sees state too
+        }
+        catch { /* ignore */ }
+        return job;
+    };
+    wrapped.__lensmcp = true;
+    proto['add'] = wrapped;
+}
+function tapWorkerEmit(mod) {
+    const Worker = mod['Worker'];
+    const proto = Worker?.prototype;
+    const orig = proto?.['emit'];
+    if (!proto || typeof orig !== 'function' || orig.__lensmcp)
+        return;
+    const wrapped = function (event, ...args) {
+        try {
+            observeWorkerEvent(this, String(event), args);
+        }
+        catch { /* never break the worker */ }
+        return orig.call(this, event, ...args);
+    };
+    wrapped.__lensmcp = true;
+    proto['emit'] = wrapped;
+}
+function observeWorkerEvent(worker, event, args) {
+    if (event !== 'active' && event !== 'completed' && event !== 'failed')
+        return;
+    const name = String(worker['name'] ?? 'queue');
+    const job = args[0];
+    // Lifecycle events join the worker LEG of the originating flow when the
+    // job carries the stamp; un-stamped jobs stay flow-less (canvas only).
+    const stamp = jobFlow(job);
+    const fctx = stamp?.flowId ? { flowId: stamp.flowId, requestId: jobLegId(name, job) } : undefined;
+    if (event === 'active') {
+        (0, emit_1.lensEmit)('queue', 'info', `processing ${job?.name}#${job?.id}`, {
+            queue: name, kind: 'queue-active', jobId: job?.id,
+        }, `queue:${name}`, fctx);
+    }
+    else if (event === 'completed') {
+        let returned;
+        try {
+            const rv = job?.returnvalue ?? args[1];
+            const s = JSON.stringify(rv);
+            returned = s && s !== 'undefined' ? (s.length > 160 ? s.slice(0, 159) + '…' : s) : undefined;
+        }
+        catch { /* unserializable */ }
+        (0, emit_1.lensEmit)('queue', 'info', `completed ${job?.name}#${job?.id}`, {
+            queue: name, kind: 'queue-completed', jobId: job?.id,
+            ...(returned ? { returned } : {}),
+        }, `queue:${name}`, fctx);
+    }
+    else {
+        const err = args[1];
+        (0, emit_1.lensEmit)('queue', 'error', `job ${job?.id} failed: ${err?.message}`, {
+            queue: name, kind: 'queue-failed', jobId: job?.id, error: String(err?.message ?? err),
+        }, `queue:${name}`, fctx);
+    }
+    if (!publishers.has(name)) {
+        // Build a snapshot Queue from the worker's own connection opts.
+        try {
+            const opts = worker['opts'];
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const mod = require('bullmq');
+            const Queue = mod['Queue'];
+            ensureStatePublisher(name, new Queue(name, { connection: opts?.['connection'] }));
+        }
+        catch { /* snapshots unavailable — lifecycle events still flow */ }
+    }
+}
+function ensureStatePublisher(name, queue) {
+    if (publishers.has(name))
+        return;
+    let lastSig = '';
+    const timer = setInterval(() => {
+        void (async () => {
+            try {
+                const counts = await queue.getJobCounts();
+                const recent = [];
+                for (const state of ['active', 'waiting', 'failed', 'completed', 'delayed']) {
+                    for (const j of await queue.getJobs([state], 0, 7)) {
+                        const to = j?.data?.['to'];
+                        recent.push({
+                            id: String(j.id), name: j.name, state, timestamp: j.timestamp ?? 0,
+                            ...(typeof to === 'string' ? { to } : {}),
+                        });
+                    }
+                }
+                recent.sort((a, b) => Number(b['timestamp']) - Number(a['timestamp']));
+                const top = recent.slice(0, 8);
+                const sig = JSON.stringify([counts, top.map((r) => `${r['id']}${r['state']}`)]);
+                if (sig === lastSig)
+                    return;
+                lastSig = sig;
+                (0, emit_1.lensEmit)('queue', 'info', `queue state: ${counts['active'] ?? 0} active · ${counts['waiting'] ?? 0} waiting · ${counts['failed'] ?? 0} failed`, { queue: name, kind: 'queue-state', counts, recent: top }, `queue:${name}`);
+            }
+            catch { /* redis hiccup — next tick */ }
+        })();
+    }, 2000);
+    timer.unref?.();
+    publishers.set(name, timer);
+}

package/lib/tap-egress.d.ts

@@ -0,0 +1,2 @@
+export declare function tapEgress(): void;
+//# sourceMappingURL=tap-egress.d.ts.map

package/lib/tap-egress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-egress.d.ts","sourceRoot":"","sources":["../../src/lib/tap-egress.ts"],"names":[],"mappings":"AA0BA,wBAAgB,SAAS,IAAI,IAAI,CAIhC"}

package/lib/tap-egress.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tapEgress = tapEgress;
+/**
+ * Egress watch, zero-touch: wraps global `fetch` AND `http`/`https.request`
+ * so ANY outbound call leaving the system (openai, stripe, a BSP…) is
+ * published to the lens (source `external`) and appears on the cluster
+ * canvas attributed to this service — observed traffic, not config.
+ *
+ * Local/cluster-internal destinations (*.local, localhost, loopback, RFC1918,
+ * unix sockets) are passed through untraced: service-to-service calls are
+ * already attributed by the gateway (`x-api-key-id`), and double edges lie.
+ */
+const emit_1 = require("./emit");
+const flow_context_1 = require("./flow-context");
+const INTERNAL = [
+    /\.local$/i,
+    /^localhost$/i,
+    /^127\./,
+    /^\[?::1\]?$/,
+    /^0\.0\.0\.0$/,
+    /^10\./,
+    /^192\.168\./,
+];
+const isInternal = (host) => host === '' || INTERNAL.some((p) => p.test(host));
+function tapEgress() {
+    tapFetch();
+    tapHttpModule('http');
+    tapHttpModule('https');
+}
+function tapFetch() {
+    const g = globalThis;
+    if (typeof g.fetch !== 'function' || g['__lensmcpFetchTap'])
+        return;
+    g['__lensmcpFetchTap'] = true;
+    const original = g.fetch.bind(globalThis);
+    g.fetch = (async (input, init) => {
+        let host = '';
+        try {
+            host = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url).hostname;
+        }
+        catch {
+            /* relative URL — internal by definition */
+        }
+        if (isInternal(host))
+            return original(input, init);
+        const t0 = Date.now();
+        const ctx = (0, flow_context_1.flowContext)(); // snapshot at the call site, before any await
+        const liveF = (0, flow_context_1.liveFlowContext)();
+        if (liveF)
+            liveF.externalCallCount = (liveF.externalCallCount ?? 0) + 1; // fan-out detector
+        const method = String(init?.method ?? 'GET').toUpperCase();
+        try {
+            const res = await original(input, init);
+            (0, emit_1.lensEmit)('external', 'info', `egress ${method} ${host} → ${res.status}`, {
+                name: host, kind: 'egress', method, host, status: res.status,
+                startedAt: t0, durationMs: Date.now() - t0,
+            }, undefined, ctx);
+            return res;
+        }
+        catch (err) {
+            (0, emit_1.lensEmit)('external', 'error', `egress ${method} ${host} failed`, {
+                name: host, kind: 'egress', method, host,
+                error: String(err?.message ?? err),
+                startedAt: t0, durationMs: Date.now() - t0,
+            }, undefined, ctx);
+            throw err;
+        }
+    });
+}
+function tapHttpModule(proto) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require(`node:${proto}`);
+    const origRequest = mod['request'];
+    if (typeof origRequest !== 'function' || origRequest.__lensmcp)
+        return;
+    const wrapped = function (...args) {
+        const req = origRequest.apply(this, args);
+        try {
+            observe(args, req);
+        }
+        catch {
+            /* never break the call */
+        }
+        return req;
+    };
+    wrapped.__lensmcp = true;
+    mod['request'] = wrapped;
+    const origGet = mod['get'];
+    if (typeof origGet === 'function') {
+        mod['get'] = function (...args) {
+            const req = wrapped.apply(this, args);
+            req.end();
+            return req;
+        };
+    }
+}
+function observe(args, req) {
+    const { host, method } = parseTarget(args);
+    if (isInternal(host))
+        return;
+    const t0 = Date.now();
+    const ctx = (0, flow_context_1.flowContext)(); // call-site scope, not response-callback scope
+    const liveH = (0, flow_context_1.liveFlowContext)();
+    if (liveH)
+        liveH.externalCallCount = (liveH.externalCallCount ?? 0) + 1; // fan-out detector
+    let done = false;
+    req.once('response', (...resArgs) => {
+        if (done)
+            return;
+        done = true;
+        const res = resArgs[0];
+        (0, emit_1.lensEmit)('external', 'info', `egress ${method} ${host} → ${res?.statusCode ?? '?'}`, {
+            name: host, kind: 'egress', method, host,
+            ...(res?.statusCode != null ? { status: res.statusCode } : {}),
+            startedAt: t0, durationMs: Date.now() - t0,
+        }, undefined, ctx);
+    });
+    req.once('error', (...errArgs) => {
+        if (done)
+            return;
+        done = true;
+        const err = errArgs[0];
+        (0, emit_1.lensEmit)('external', 'error', `egress ${method} ${host} failed`, {
+            name: host, kind: 'egress', method, host,
+            error: String(err?.message ?? err), startedAt: t0, durationMs: Date.now() - t0,
+        }, undefined, ctx);
+    });
+}
+function parseTarget(args) {
+    let host = '';
+    let method = 'GET';
+    for (const a of args) {
+        if (typeof a === 'string') {
+            try {
+                host = new URL(a).hostname;
+            }
+            catch {
+                /* not a URL */
+            }
+        }
+        else if (a instanceof URL) {
+            host = a.hostname;
+        }
+        else if (a && typeof a === 'object') {
+            const o = a;
+            if (typeof o['method'] === 'string')
+                method = o['method'].toUpperCase();
+            if (typeof o['socketPath'] === 'string')
+                return { host: '', method }; // unix sock → internal
+            if (typeof o['hostname'] === 'string' && o['hostname'])
+                host = o['hostname'];
+            else if (typeof o['host'] === 'string' && o['host'])
+                host = o['host'].split(':')[0] ?? '';
+        }
+    }
+    return { host, method };
+}

package/lib/tap-exec.d.ts

@@ -0,0 +1,2 @@
+export declare function tapExec(): void;
+//# sourceMappingURL=tap-exec.d.ts.map

package/lib/tap-exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-exec.d.ts","sourceRoot":"","sources":["../../src/lib/tap-exec.ts"],"names":[],"mappings":"AA4DA,wBAAgB,OAAO,IAAI,IAAI,CA4D9B"}

package/lib/tap-exec.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tapExec = tapExec;
+/**
+ * child_process tap (source `exec`): every spawn/exec/fork a pod performs is
+ * a fact worth seeing — shell-outs are the least visible side effects a
+ * service has. Async forms emit ONE event at exit (cmd, code, duration);
+ * sync forms time the call. Internal Node refs aren't double-counted:
+ * `exec` → internal `execFile` → internal `spawn` bypasses the patched
+ * exports, so each public call emits exactly once.
+ */
+const emit_1 = require("./emit");
+const fmtCmd = (file, args) => {
+    const a = Array.isArray(args) ? args.map(String).slice(0, 8).join(' ') : '';
+    return `${String(file)}${a ? ' ' + a : ''}`.slice(0, 200);
+};
+function wrap(obj, key, make) {
+    const orig = obj[key];
+    if (typeof orig !== 'function' || orig.__lensmcp)
+        return;
+    const wrapped = make(orig);
+    wrapped.__lensmcp = true;
+    obj[key] = wrapped;
+}
+function observeChild(via, cmd, child) {
+    if (!child || typeof child.once !== 'function')
+        return;
+    // On current Node `exec()` dispatches to the module-export `execFile`, which
+    // dispatches to `spawn` — all three are wrapped, so the SAME child passes
+    // through multiple wrappers. Tag it once: the OUTERMOST public call wins
+    // (richest `via`/cmd), inner re-observations bail → exactly one event.
+    const c = child;
+    if (c.__lensmcpObserved)
+        return;
+    c.__lensmcpObserved = true;
+    const t0 = Date.now();
+    child.once('exit', (...args) => {
+        const code = args[0];
+        const signal = args[1];
+        (0, emit_1.lensEmit)('exec', code === 0 ? 'info' : 'error', `exec ${cmd.split(' ')[0]} → ${code ?? signal}`, {
+            name: 'exec', kind: 'exec', cmd, via,
+            ...(code != null ? { code } : {}),
+            ...(signal ? { signal } : {}),
+            durationMs: Date.now() - t0,
+            ...(child.pid ? { pid: child.pid } : {}),
+        });
+    });
+    child.once('error', (...args) => {
+        const err = args[0];
+        (0, emit_1.lensEmit)('exec', 'error', `exec ${cmd.split(' ')[0]} failed to start`, {
+            name: 'exec', kind: 'exec', cmd, via,
+            error: String(err?.message ?? err), durationMs: Date.now() - t0,
+        });
+    });
+}
+function tapExec() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const cp = require('node:child_process');
+    for (const key of ['spawn', 'fork']) {
+        wrap(cp, key, (orig) => function (file, ...rest) {
+            const args = Array.isArray(rest[0]) ? rest[0] : [];
+            const child = orig.call(this, file, ...rest);
+            try {
+                observeChild(key, fmtCmd(file, args), child);
+            }
+            catch { /* never break the spawn */ }
+            return child;
+        });
+    }
+    wrap(cp, 'exec', (orig) => function (cmd, ...rest) {
+        const child = orig.call(this, cmd, ...rest);
+        try {
+            observeChild('exec', String(cmd).slice(0, 200), child);
+        }
+        catch { /* ignore */ }
+        return child;
+    });
+    wrap(cp, 'execFile', (orig) => function (file, ...rest) {
+        const args = Array.isArray(rest[0]) ? rest[0] : [];
+        const child = orig.call(this, file, ...rest);
+        try {
+            observeChild('execFile', fmtCmd(file, args), child);
+        }
+        catch { /* ignore */ }
+        return child;
+    });
+    for (const key of ['execSync', 'execFileSync', 'spawnSync']) {
+        wrap(cp, key, (orig) => function (file, ...rest) {
+            const args = Array.isArray(rest[0]) ? rest[0] : [];
+            const cmd = key === 'execSync' ? String(file).slice(0, 200) : fmtCmd(file, args);
+            const t0 = Date.now();
+            try {
+                const r = orig.call(this, file, ...rest);
+                const status = r && typeof r === 'object' && 'status' in r
+                    ? (r.status ?? 0)
+                    : 0;
+                (0, emit_1.lensEmit)('exec', status === 0 ? 'info' : 'error', `exec ${cmd.split(' ')[0]} → ${status}`, {
+                    name: 'exec', kind: 'exec', cmd, via: key, code: status, durationMs: Date.now() - t0, sync: true,
+                });
+                return r;
+            }
+            catch (err) {
+                (0, emit_1.lensEmit)('exec', 'error', `exec ${cmd.split(' ')[0]} failed`, {
+                    name: 'exec', kind: 'exec', cmd, via: key,
+                    error: String(err?.message ?? err), durationMs: Date.now() - t0, sync: true,
+                });
+                throw err;
+            }
+        });
+    }
+}

package/lib/tap-fs.d.ts

@@ -0,0 +1,2 @@
+export declare function tapFs(): void;
+//# sourceMappingURL=tap-fs.d.ts.map

package/lib/tap-fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-fs.d.ts","sourceRoot":"","sources":["../../src/lib/tap-fs.ts"],"names":[],"mappings":"AA6FA,wBAAgB,KAAK,IAAI,IAAI,CA6E5B"}