@rootcat/node 0.0.0-stage → 0.2.0

package/dist/callsite.d.ts

@@ -0,0 +1,109 @@
+import { TraceMap } from '@jridgewell/trace-mapping';
+/** CallSiteLocation is one resolved frame. */
+export interface CallSiteLocation {
+    /** file is an absolute path, or a bundler path such as app/route.ts. */
+    file: string;
+    /** line is 1-based. */
+    line: number;
+    /** column is 1-based, 0 when unknown. */
+    column: number;
+    /** function is the enclosing function's name, "" when anonymous. */
+    function: string;
+}
+type V8CallSite = NodeJS.CallSite;
+/** defaultDepth is how many frames a full capture walks. */
+export declare const defaultDepth = 32;
+/**
+ * shortDepth is the first walk from an entry wrapper: its caller is the
+ * application or an ORM a few frames above it. A stack frame costs about
+ * a microsecond to collect; the full walk is the fallback.
+ */
+export declare const shortDepth = 3;
+/** Bounds on source maps: per map, and for all maps held at once. */
+export declare const maxSourceMapBytes: number;
+export declare const sourceMapBudgetBytes: number;
+/** maxDisplayPathBytes keeps code.filepath within the agent's 128-byte bound. */
+export declare const maxDisplayPathBytes = 120;
+/**
+ * captureFrames returns up to depth frames as V8 CallSite objects,
+ * starting below the topmost call of above (or of captureFrames itself).
+ * Error.prepareStackTrace and Error.stackTraceLimit are swapped for the
+ * duration of the capture only. When above is not on the stack, V8 gives
+ * nothing; the caller falls back to an uncut walk.
+ */
+export declare function captureFrames(depth: number, above?: Function): V8CallSite[];
+/**
+ * normalizeFile turns a CallSite file name into a path: file URLs become
+ * paths, webpack-internal URLs lose their prefix; node: internals, eval
+ * and other non-paths give undefined.
+ */
+export declare function normalizeFile(file: string | null | undefined): string | undefined;
+/**
+ * isAppFile reports whether a path belongs to the application: no
+ * node_modules segment (absolute or bundler-relative, as a source map
+ * names a bundled library) and not this package's own code.
+ */
+export declare function isAppFile(file: string, own?: readonly string[]): boolean;
+/** firstAppFrame returns the first captured frame whose generated file is application code, unresolved. */
+export declare function firstAppFrame(sites: readonly V8CallSite[], isApp?: (file: string) => boolean): CallSiteLocation | undefined;
+/**
+ * appLocation walks the frames, resolves each candidate through its
+ * source map, and returns the first whose original source is application
+ * code: a frame in a bundle that maps into a bundled library is passed
+ * over, as an unbundled library frame is.
+ */
+export declare function appLocation(sites: readonly V8CallSite[], isApp?: (file: string) => boolean): CallSiteLocation | undefined;
+/** resetSourceMapCache forgets loaded maps (tests). */
+export declare function resetSourceMapCache(): void;
+/** sourceMapBytesHeld reports what the cache holds (tests). */
+export declare function sourceMapBytesHeld(): number;
+/**
+ * sourceMapFor loads the source map a generated file points at through
+ * its sourceMappingURL comment (inline data URL or a file beside it),
+ * once per file, and remembers the result; null when none. A map over
+ * maxSourceMapBytes is not read; the maps held together stay within
+ * sourceMapBudgetBytes, the least recently loaded given up first (and
+ * read again if their file comes back). The read is synchronous and
+ * happens the first time a file is seen on a captured stack.
+ */
+export declare function sourceMapFor(file: string): TraceMap | null;
+/** sourceMappingURL finds the last sourceMappingURL comment in text. */
+export declare function sourceMappingURL(text: string): string | undefined;
+/**
+ * originalPath makes a mapped source readable: file URLs become paths and
+ * bundler schemes (webpack://, turbopack://) are reduced to the project
+ * relative path they carry.
+ */
+export declare function originalPath(source: string): string;
+/**
+ * resolveLocation maps a generated position to the original source when
+ * the file has a source map: the one Node already holds (with
+ * --enable-source-maps, or a loader such as tsx registering its maps),
+ * else the file's own. Otherwise the location is returned as is.
+ */
+export declare function resolveLocation(location: CallSiteLocation): CallSiteLocation;
+/**
+ * parseStack finds the first application frame in a formatted V8 stack
+ * (one a driver captured itself, such as postgres.js's query origin) and
+ * resolves it. undefined when there is none.
+ */
+export declare function parseStack(stack: string, isApp?: (file: string) => boolean): CallSiteLocation | undefined;
+/**
+ * captureCallSite is the whole operation: capture, pick the application
+ * frame, resolve it. From an entry wrapper (above), a short walk below
+ * the wrapper first, the full walk only when that finds no application
+ * frame. undefined when no application frame is on the stack.
+ */
+export declare function captureCallSite(depth?: number, isApp?: (file: string) => boolean, above?: Function): CallSiteLocation | undefined;
+/**
+ * displayPath is what code.filepath carries: a bundler path as it is, a
+ * file under the working directory relative to it, any other file
+ * relative to the parent of its nearest package.json directory (so it
+ * names its package), and at most maxDisplayPathBytes from the end, so
+ * the file name survives the agent's bound. The server's absolute layout
+ * (a home directory, a deploy path) is not sent.
+ */
+export declare function displayPath(file: string, cwd?: string): string;
+/** clipFromStart keeps the last bytes of a path, cut at a segment. */
+export declare function clipFromStart(text: string, limit: number): string;
+export {};

package/dist/callsite.js

@@ -0,0 +1,565 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxDisplayPathBytes = exports.sourceMapBudgetBytes = exports.maxSourceMapBytes = exports.shortDepth = exports.defaultDepth = void 0;
+exports.captureFrames = captureFrames;
+exports.normalizeFile = normalizeFile;
+exports.isAppFile = isAppFile;
+exports.firstAppFrame = firstAppFrame;
+exports.appLocation = appLocation;
+exports.resetSourceMapCache = resetSourceMapCache;
+exports.sourceMapBytesHeld = sourceMapBytesHeld;
+exports.sourceMapFor = sourceMapFor;
+exports.sourceMappingURL = sourceMappingURL;
+exports.originalPath = originalPath;
+exports.resolveLocation = resolveLocation;
+exports.parseStack = parseStack;
+exports.captureCallSite = captureCallSite;
+exports.displayPath = displayPath;
+exports.clipFromStart = clipFromStart;
+// Call-site capture: the application frame that issued a client operation.
+// The stack is captured as V8 CallSite objects (no string formatting),
+// starting below the wrapper that asks when there is one, so the walk is
+// a few frames rather than the whole driver; each frame outside
+// node_modules, Node's internals and this package is resolved through its
+// file's source map, and the first whose original source is itself
+// application code (not a bundled library) is kept. Source maps are read
+// once per file and held within a byte budget.
+const fs = __importStar(require("node:fs"));
+const nodeModule = __importStar(require("node:module"));
+const path = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const trace_mapping_1 = require("@jridgewell/trace-mapping");
+/** defaultDepth is how many frames a full capture walks. */
+exports.defaultDepth = 32;
+/**
+ * shortDepth is the first walk from an entry wrapper: its caller is the
+ * application or an ORM a few frames above it. A stack frame costs about
+ * a microsecond to collect; the full walk is the fallback.
+ */
+exports.shortDepth = 3;
+/** Bounds on source maps: per map, and for all maps held at once. */
+exports.maxSourceMapBytes = 32 * 1024 * 1024;
+exports.sourceMapBudgetBytes = 64 * 1024 * 1024;
+const maxTailBytes = 4096;
+const maxCachedFiles = 512;
+/** maxDisplayPathBytes keeps code.filepath within the agent's 128-byte bound. */
+exports.maxDisplayPathBytes = 120;
+/** ownDirectories are this package's own code, never a call site. */
+const packageRoot = path.resolve(__dirname, '..');
+const ownDirectories = [path.join(packageRoot, 'dist'), path.join(packageRoot, 'src')];
+/**
+ * captureFrames returns up to depth frames as V8 CallSite objects,
+ * starting below the topmost call of above (or of captureFrames itself).
+ * Error.prepareStackTrace and Error.stackTraceLimit are swapped for the
+ * duration of the capture only. When above is not on the stack, V8 gives
+ * nothing; the caller falls back to an uncut walk.
+ */
+function captureFrames(depth, above) {
+    const prepare = Error.prepareStackTrace;
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = depth;
+    Error.prepareStackTrace = (_error, sites) => sites;
+    const holder = {};
+    try {
+        Error.captureStackTrace(holder, above ?? captureFrames);
+        const sites = holder.stack;
+        return Array.isArray(sites) ? sites : [];
+    }
+    finally {
+        Error.prepareStackTrace = prepare;
+        Error.stackTraceLimit = limit;
+    }
+}
+/**
+ * normalizeFile turns a CallSite file name into a path: file URLs become
+ * paths, webpack-internal URLs lose their prefix; node: internals, eval
+ * and other non-paths give undefined.
+ */
+function normalizeFile(file) {
+    if (!file) {
+        return undefined;
+    }
+    if (file.startsWith('node:')) {
+        return undefined;
+    }
+    if (file.startsWith('file://')) {
+        try {
+            return (0, node_url_1.fileURLToPath)(file);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (file.startsWith('webpack-internal:///')) {
+        return stripBundlerPrefix(file);
+    }
+    if (!path.isAbsolute(file)) {
+        return undefined;
+    }
+    return file;
+}
+const nodeModulesSegment = /(^|[\\/])node_modules[\\/]/;
+/**
+ * isAppFile reports whether a path belongs to the application: no
+ * node_modules segment (absolute or bundler-relative, as a source map
+ * names a bundled library) and not this package's own code.
+ */
+function isAppFile(file, own = ownDirectories) {
+    if (nodeModulesSegment.test(file)) {
+        return false;
+    }
+    for (const dir of own) {
+        if (file === dir || file.startsWith(dir + path.sep)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** firstAppFrame returns the first captured frame whose generated file is application code, unresolved. */
+function firstAppFrame(sites, isApp = isAppFile) {
+    for (const site of sites) {
+        const frame = frameOf(site, isApp);
+        if (frame) {
+            return frame;
+        }
+    }
+    return undefined;
+}
+function frameOf(site, isApp) {
+    let file;
+    try {
+        file = normalizeFile(site.getFileName());
+    }
+    catch {
+        return undefined;
+    }
+    if (!file || !isApp(file)) {
+        return undefined;
+    }
+    return { file, line: site.getLineNumber() ?? 0, column: site.getColumnNumber() ?? 0, function: functionName(site) };
+}
+/**
+ * appLocation walks the frames, resolves each candidate through its
+ * source map, and returns the first whose original source is application
+ * code: a frame in a bundle that maps into a bundled library is passed
+ * over, as an unbundled library frame is.
+ */
+function appLocation(sites, isApp = isAppFile) {
+    for (const site of sites) {
+        const frame = frameOf(site, isApp);
+        if (!frame) {
+            continue;
+        }
+        const resolved = resolveLocation(frame);
+        if (resolved !== frame && !isApp(resolved.file)) {
+            continue;
+        }
+        return resolved;
+    }
+    return undefined;
+}
+function functionName(site) {
+    try {
+        // getMethodName() searches the receiver's properties and costs more
+        // than the rest of a frame together; the function's own name suffices.
+        const name = site.getFunctionName() ?? '';
+        return name.length > 256 ? name.slice(0, 256) : name;
+    }
+    catch {
+        return '';
+    }
+}
+const sourceMaps = new Map();
+let heldBytes = 0;
+/** resetSourceMapCache forgets loaded maps (tests). */
+function resetSourceMapCache() {
+    sourceMaps.clear();
+    resolvedPositions.clear();
+    heldBytes = 0;
+}
+/** sourceMapBytesHeld reports what the cache holds (tests). */
+function sourceMapBytesHeld() {
+    return heldBytes;
+}
+/**
+ * sourceMapFor loads the source map a generated file points at through
+ * its sourceMappingURL comment (inline data URL or a file beside it),
+ * once per file, and remembers the result; null when none. A map over
+ * maxSourceMapBytes is not read; the maps held together stay within
+ * sourceMapBudgetBytes, the least recently loaded given up first (and
+ * read again if their file comes back). The read is synchronous and
+ * happens the first time a file is seen on a captured stack.
+ */
+function sourceMapFor(file) {
+    const cached = sourceMaps.get(file);
+    if (cached) {
+        return cached.map;
+    }
+    const entry = loadSourceMap(file);
+    while (sourceMaps.size > 0 && (sourceMaps.size >= maxCachedFiles || heldBytes + entry.bytes > exports.sourceMapBudgetBytes)) {
+        const oldest = sourceMaps.keys().next().value;
+        heldBytes -= sourceMaps.get(oldest).bytes;
+        sourceMaps.delete(oldest);
+    }
+    if (entry.bytes > exports.sourceMapBudgetBytes) {
+        sourceMaps.set(file, { map: null, bytes: 0 });
+        return null;
+    }
+    sourceMaps.set(file, entry);
+    heldBytes += entry.bytes;
+    return entry.map;
+}
+const none = { map: null, bytes: 0 };
+function loadSourceMap(file) {
+    if (!path.isAbsolute(file)) {
+        return none;
+    }
+    const tail = readTail(file, maxTailBytes);
+    if (tail === undefined) {
+        return none;
+    }
+    const url = sourceMappingURL(tail);
+    if (!url) {
+        return none;
+    }
+    try {
+        if (url.startsWith('data:')) {
+            const text = inlineMap(url);
+            return parseMap(text, (0, node_url_1.pathToFileURL)(file).href);
+        }
+        if (/^[a-z]+:/i.test(url) && !url.startsWith('file:')) {
+            return none; // a remote map is never fetched
+        }
+        // A bundler may percent-encode the map's name ([chunk].js.map).
+        const mapFile = url.startsWith('file:') ? (0, node_url_1.fileURLToPath)(url) : path.resolve(path.dirname(file), decodeMapURL(url));
+        const stat = fs.statSync(mapFile);
+        if (!stat.isFile() || stat.size > exports.maxSourceMapBytes) {
+            return none;
+        }
+        return parseMap(fs.readFileSync(mapFile, 'utf8'), (0, node_url_1.pathToFileURL)(mapFile).href);
+    }
+    catch {
+        return none;
+    }
+}
+function decodeMapURL(url) {
+    try {
+        return decodeURIComponent(url);
+    }
+    catch {
+        return url;
+    }
+}
+function parseMap(text, mapUrl) {
+    if (text === undefined || text.length > exports.maxSourceMapBytes) {
+        return none;
+    }
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== 'object') {
+        return none;
+    }
+    // The decoded map holds about what its text did.
+    return { map: new trace_mapping_1.TraceMap(parsed, mapUrl), bytes: text.length };
+}
+function inlineMap(url) {
+    const comma = url.indexOf(',');
+    if (comma < 0) {
+        return undefined;
+    }
+    const header = url.slice(5, comma);
+    const payload = url.slice(comma + 1);
+    if (!header.startsWith('application/json')) {
+        return undefined;
+    }
+    if (header.endsWith(';base64')) {
+        if (payload.length > (exports.maxSourceMapBytes * 4) / 3) {
+            return undefined;
+        }
+        return Buffer.from(payload, 'base64').toString('utf8');
+    }
+    return decodeURIComponent(payload);
+}
+/** sourceMappingURL finds the last sourceMappingURL comment in text. */
+function sourceMappingURL(text) {
+    const pattern = /\/[/*][#@]\s*sourceMappingURL=([^\s'"*]+)/g;
+    let url;
+    for (;;) {
+        const match = pattern.exec(text);
+        if (!match) {
+            return url;
+        }
+        url = match[1];
+    }
+}
+function readTail(file, bytes) {
+    let fd;
+    try {
+        fd = fs.openSync(file, 'r');
+        const size = fs.fstatSync(fd).size;
+        const length = Math.min(size, bytes);
+        const buffer = Buffer.alloc(length);
+        const n = fs.readSync(fd, buffer, 0, length, size - length);
+        return buffer.toString('utf8', 0, n);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined) {
+            fs.closeSync(fd);
+        }
+    }
+}
+/**
+ * originalPath makes a mapped source readable: file URLs become paths and
+ * bundler schemes (webpack://, turbopack://) are reduced to the project
+ * relative path they carry.
+ */
+function originalPath(source) {
+    if (source.startsWith('file://')) {
+        try {
+            return (0, node_url_1.fileURLToPath)(source);
+        }
+        catch {
+            return source;
+        }
+    }
+    if (/^(webpack|turbopack|webpack-internal):/.test(source)) {
+        return stripBundlerPrefix(source);
+    }
+    return source;
+}
+function stripBundlerPrefix(source) {
+    // webpack:///./src/a.ts, webpack://name/./src/a.ts,
+    // webpack-internal:///(rsc)/./app/a.ts, turbopack://[project]/app/a.ts
+    let rest = source.replace(/^[a-z-]+:\/\/\/?/, '');
+    rest = rest.replace(/^\[project\]\//, '');
+    rest = rest.replace(/^[^/]*\/(?=\.\/)/, '');
+    rest = rest.replace(/^\([a-z-]+\)\//, '');
+    rest = rest.replace(/^(\.\/)+/, '');
+    return rest;
+}
+const findSourceMap = nodeModule.findSourceMap;
+/**
+ * resolveLocation maps a generated position to the original source when
+ * the file has a source map: the one Node already holds (with
+ * --enable-source-maps, or a loader such as tsx registering its maps),
+ * else the file's own. Otherwise the location is returned as is.
+ */
+function resolveLocation(location) {
+    if (location.line < 1) {
+        return location;
+    }
+    // A call site recurs: its position is resolved once.
+    const key = location.file + ':' + location.line + ':' + location.column;
+    const known = resolvedPositions.get(key);
+    if (known) {
+        return known;
+    }
+    const resolved = resolveUncached(location);
+    if (resolvedPositions.size >= maxResolvedPositions) {
+        resolvedPositions.clear();
+    }
+    resolvedPositions.set(key, resolved);
+    return resolved;
+}
+const resolvedPositions = new Map();
+const maxResolvedPositions = 8192;
+function resolveUncached(location) {
+    try {
+        // Node holds maps only with source maps enabled (--enable-source-maps,
+        // or a loader such as tsx turning them on).
+        const enabled = process.sourceMapsEnabled !== false;
+        const held = enabled && typeof findSourceMap === 'function' ? findSourceMap(location.file) : undefined;
+        const origin = held?.findOrigin?.(location.line, Math.max(1, location.column));
+        if (origin && typeof origin.fileName === 'string' && typeof origin.lineNumber === 'number') {
+            return { file: originalPath(origin.fileName), line: origin.lineNumber, column: origin.columnNumber ?? 0, function: origin.name || location.function };
+        }
+    }
+    catch {
+        // fall through to the file's own map
+    }
+    const map = sourceMapFor(location.file);
+    if (!map) {
+        return location;
+    }
+    try {
+        const position = (0, trace_mapping_1.originalPositionFor)(map, { line: location.line, column: Math.max(0, location.column - 1) });
+        if (position.source == null || position.line == null) {
+            return location;
+        }
+        return {
+            file: originalPath(position.source),
+            line: position.line,
+            column: position.column == null ? 0 : position.column + 1,
+            function: position.name ?? location.function,
+        };
+    }
+    catch {
+        return location;
+    }
+}
+/** Bounds on parsing a stack a driver already holds. */
+const maxParsedStackLines = 64;
+const stackLine = /^\s*at (?:async )?(?:new )?(?:(.*?) )?\(?(.+?):(\d+):(\d+)\)?$/;
+/**
+ * parseStack finds the first application frame in a formatted V8 stack
+ * (one a driver captured itself, such as postgres.js's query origin) and
+ * resolves it. undefined when there is none.
+ */
+function parseStack(stack, isApp = isAppFile) {
+    if (typeof stack !== 'string') {
+        return undefined;
+    }
+    const lines = stack.split('\n', maxParsedStackLines);
+    for (const line of lines) {
+        const match = stackLine.exec(line);
+        if (!match) {
+            continue;
+        }
+        const file = normalizeFile(match[2]);
+        if (!file || !isApp(file)) {
+            continue;
+        }
+        const name = match[1] ?? '';
+        const frame = { file, line: Number(match[3]), column: Number(match[4]), function: name === '<anonymous>' || name.endsWith('.<anonymous>') ? '' : name.slice(0, 256) };
+        const resolved = resolveLocation(frame);
+        if (resolved !== frame && !isApp(resolved.file)) {
+            continue;
+        }
+        return resolved;
+    }
+    return undefined;
+}
+/**
+ * captureCallSite is the whole operation: capture, pick the application
+ * frame, resolve it. From an entry wrapper (above), a short walk below
+ * the wrapper first, the full walk only when that finds no application
+ * frame. undefined when no application frame is on the stack.
+ */
+function captureCallSite(depth = exports.defaultDepth, isApp = isAppFile, above) {
+    const full = typeof depth === 'number' && depth > 0 ? depth : exports.defaultDepth;
+    if (above) {
+        const short = captureFrames(Math.min(exports.shortDepth, full), above);
+        const found = appLocation(short, isApp);
+        if (found) {
+            return found;
+        }
+        if (short.length > 0 && short.length < Math.min(exports.shortDepth, full)) {
+            return undefined; // the stack ended within the short walk
+        }
+        const rest = captureFrames(full, above);
+        return appLocation(rest.length > 0 ? rest : captureFrames(full), isApp);
+    }
+    return appLocation(captureFrames(full), isApp);
+}
+const displayPaths = new Map();
+const packageRoots = new Map();
+/**
+ * displayPath is what code.filepath carries: a bundler path as it is, a
+ * file under the working directory relative to it, any other file
+ * relative to the parent of its nearest package.json directory (so it
+ * names its package), and at most maxDisplayPathBytes from the end, so
+ * the file name survives the agent's bound. The server's absolute layout
+ * (a home directory, a deploy path) is not sent.
+ */
+function displayPath(file, cwd = process.cwd()) {
+    const key = cwd + '\0' + file;
+    const known = displayPaths.get(key);
+    if (known !== undefined) {
+        return known;
+    }
+    let shown = file;
+    if (path.isAbsolute(file)) {
+        const relative = path.relative(cwd, file);
+        if (relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+            shown = relative;
+        }
+        else {
+            const root = packageRootOf(path.dirname(file));
+            shown = root ? path.relative(path.dirname(root), file) : path.join(path.basename(path.dirname(file)), path.basename(file));
+        }
+    }
+    shown = clipFromStart(shown.split(path.sep).join('/'), exports.maxDisplayPathBytes);
+    if (displayPaths.size >= 4096) {
+        displayPaths.clear();
+    }
+    displayPaths.set(key, shown);
+    return shown;
+}
+function packageRootOf(dir) {
+    const visited = [];
+    let current = dir;
+    let found = null;
+    for (let level = 0; level < 12; level++) {
+        const known = packageRoots.get(current);
+        if (known !== undefined) {
+            found = known;
+            break;
+        }
+        visited.push(current);
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            found = current;
+            break;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    for (const v of visited) {
+        packageRoots.set(v, found);
+    }
+    return found ?? undefined;
+}
+/** clipFromStart keeps the last bytes of a path, cut at a segment. */
+function clipFromStart(text, limit) {
+    if (Buffer.byteLength(text) <= limit) {
+        return text;
+    }
+    let tail = text;
+    while (Buffer.byteLength(tail) > limit - 4) {
+        const slash = tail.indexOf('/', 1);
+        if (slash < 0) {
+            tail = tail.slice(tail.length - (limit - 4));
+            break;
+        }
+        tail = tail.slice(slash);
+    }
+    return '...' + (tail.startsWith('/') ? tail : '/' + tail);
+}
+//# sourceMappingURL=callsite.js.map