@zintrust/trace 0.4.75

package/dist/storage/TraceStorage.js

@@ -0,0 +1,195 @@
+import { familyHash } from '../utils/familyHash';
+const TABLE_ENTRIES = 'zin_trace_entries';
+const TABLE_TAGS = 'zin_trace_entries_tags';
+const TABLE_MONITORING = 'zin_trace_monitoring';
+const generateUuid = () => crypto.randomUUID();
+const rowToEntry = (row, tags) => ({
+    uuid: row.uuid,
+    batchId: row.batch_id,
+    familyHash: row.family_hash ?? undefined,
+    type: row.type,
+    content: JSON.parse(row.content),
+    tags,
+    isLatest: Boolean(row.is_latest),
+    createdAt: row.created_at,
+});
+const insertTags = async (db, uuid, tags) => {
+    if (tags.length === 0)
+        return;
+    await Promise.all(tags.map(async (tag) => {
+        await db.execute(`INSERT OR IGNORE INTO ${TABLE_TAGS} (entry_uuid, tag) VALUES (?, ?)`, [
+            uuid,
+            tag,
+        ]);
+    }));
+};
+const buildEntryFilters = (opts) => {
+    const conditions = [];
+    const params = [];
+    if (opts.type) {
+        conditions.push('e.type = ?');
+        params.push(opts.type);
+    }
+    if (opts.batchId) {
+        conditions.push('e.batch_id = ?');
+        params.push(opts.batchId);
+    }
+    if (opts.from) {
+        conditions.push('e.created_at >= ?');
+        params.push(opts.from);
+    }
+    if (opts.to) {
+        conditions.push('e.created_at <= ?');
+        params.push(opts.to);
+    }
+    let joinClause = '';
+    if (opts.tag) {
+        joinClause = `INNER JOIN ${TABLE_TAGS} t ON t.entry_uuid = e.uuid AND t.tag = ?`;
+        params.unshift(opts.tag);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const countParams = opts.tag ? [opts.tag, ...params.slice(1)] : [...params];
+    return { joinClause, whereClause, params, countParams };
+};
+const loadTagsByUuid = async (db, uuids) => {
+    const tagsByUuid = new Map();
+    if (uuids.length === 0)
+        return tagsByUuid;
+    const tagRows = (await db.query(`SELECT entry_uuid, tag FROM ${TABLE_TAGS} WHERE entry_uuid IN (${uuids.map(() => '?').join(',')})`, uuids));
+    for (const tagRow of tagRows) {
+        const tags = tagsByUuid.get(tagRow.entry_uuid) ?? [];
+        tags.push(tagRow.tag);
+        tagsByUuid.set(tagRow.entry_uuid, tags);
+    }
+    return tagsByUuid;
+};
+// The storage facade intentionally groups related DB operations in one factory.
+// eslint-disable-next-line max-lines-per-function
+const createStorage = (db) => {
+    const writeEntry = async (entry) => {
+        const uuid = entry.uuid || generateUuid();
+        await db.execute(`INSERT INTO ${TABLE_ENTRIES} (uuid, batch_id, family_hash, type, content, is_latest, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+            uuid,
+            entry.batchId,
+            entry.familyHash ?? null,
+            entry.type,
+            JSON.stringify(entry.content),
+            entry.isLatest ? 1 : 0,
+            entry.createdAt,
+        ]);
+        await insertTags(db, uuid, entry.tags);
+    };
+    const updateEntry = async (uuid, patch) => {
+        const sets = [];
+        const params = [];
+        if (patch.content !== undefined) {
+            sets.push('content = ?');
+            params.push(JSON.stringify(patch.content));
+        }
+        if (patch.isLatest !== undefined) {
+            sets.push('is_latest = ?');
+            params.push(patch.isLatest ? 1 : 0);
+        }
+        if (sets.length === 0)
+            return;
+        params.push(uuid);
+        await db.execute(`UPDATE ${TABLE_ENTRIES} SET ${sets.join(', ')} WHERE uuid = ?`, params);
+    };
+    const markFamilyStale = async (hash, exceptUuid) => {
+        await db.execute(`UPDATE ${TABLE_ENTRIES} SET is_latest = 0
+       WHERE family_hash = ? AND uuid != ? AND is_latest = 1`, [hash, exceptUuid]);
+    };
+    const queryEntries = async (opts) => {
+        const page = opts.page ?? 1;
+        const perPage = opts.perPage ?? 50;
+        const offset = (page - 1) * perPage;
+        const { joinClause, whereClause, params, countParams } = buildEntryFilters(opts);
+        const countResult = (await db.queryOne(`SELECT COUNT(*) as cnt FROM ${TABLE_ENTRIES} e ${joinClause} ${whereClause}`, countParams));
+        const total = countResult?.cnt ?? 0;
+        const rows = (await db.query(`SELECT e.id, e.uuid, e.batch_id, e.family_hash, e.type, e.content, e.is_latest, e.created_at
+       FROM ${TABLE_ENTRIES} e ${joinClause} ${whereClause}
+       ORDER BY e.created_at DESC, e.id DESC
+       LIMIT ? OFFSET ?`, [...params, perPage, offset]));
+        const tagsByUuid = await loadTagsByUuid(db, rows.map((row) => row.uuid));
+        return {
+            data: rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? [])),
+            total,
+        };
+    };
+    const getEntry = async (uuid) => {
+        const row = (await db.queryOne(`SELECT id, uuid, batch_id, family_hash, type, content, is_latest, created_at
+       FROM ${TABLE_ENTRIES}
+       WHERE uuid = ?`, [uuid]));
+        if (!row)
+            return null;
+        const tags = (await db.query(`SELECT tag FROM ${TABLE_TAGS} WHERE entry_uuid = ?`, [
+            uuid,
+        ]));
+        return rowToEntry(row, tags.map((tag) => tag.tag));
+    };
+    const getBatch = async (batchId) => {
+        const rows = (await db.query(`SELECT id, uuid, batch_id, family_hash, type, content, is_latest, created_at
+       FROM ${TABLE_ENTRIES}
+       WHERE batch_id = ?
+       ORDER BY created_at ASC, id ASC`, [batchId]));
+        if (rows.length === 0)
+            return [];
+        const tagsByUuid = await loadTagsByUuid(db, rows.map((row) => row.uuid));
+        return rows.map((row) => rowToEntry(row, tagsByUuid.get(row.uuid) ?? []));
+    };
+    const prune = async (olderThanMs, keepExceptions = false) => {
+        const countResult = (await db.queryOne(`SELECT COUNT(*) as cnt FROM ${TABLE_ENTRIES}
+       WHERE created_at < ?
+       ${keepExceptions ? "AND type != 'exception'" : ''}`, [olderThanMs]));
+        const deleted = countResult?.cnt ?? 0;
+        if (deleted === 0)
+            return 0;
+        await db.execute(`DELETE FROM ${TABLE_ENTRIES}
+       WHERE created_at < ?
+       ${keepExceptions ? "AND type != 'exception'" : ''}`, [olderThanMs]);
+        return deleted;
+    };
+    const clear = async () => {
+        await db.execute(`DELETE FROM ${TABLE_ENTRIES}`, []);
+    };
+    const getMonitoring = async () => {
+        const rows = (await db.query(`SELECT tag FROM ${TABLE_MONITORING}`, []));
+        return rows.map((row) => row.tag);
+    };
+    const addMonitoring = async (tag) => {
+        await db.execute(`INSERT OR IGNORE INTO ${TABLE_MONITORING} (tag) VALUES (?)`, [tag]);
+    };
+    const removeMonitoring = async (tag) => {
+        await db.execute(`DELETE FROM ${TABLE_MONITORING} WHERE tag = ?`, [tag]);
+    };
+    const stats = async () => {
+        const rows = (await db.query(`SELECT type, COUNT(*) as cnt FROM ${TABLE_ENTRIES} GROUP BY type`, []));
+        const output = {};
+        for (const row of rows) {
+            output[row.type] = row.cnt;
+        }
+        return output;
+    };
+    return {
+        writeEntry,
+        updateEntry,
+        markFamilyStale,
+        queryEntries,
+        getEntry,
+        getBatch,
+        prune,
+        clear,
+        getMonitoring,
+        addMonitoring,
+        removeMonitoring,
+        stats,
+    };
+};
+const resolveStorage = (db) => {
+    return createStorage(db);
+};
+const reset = () => {
+    return;
+};
+export const TraceStorage = Object.freeze({ resolveStorage, reset, familyHash });

package/dist/storage/index.d.ts

@@ -0,0 +1,2 @@
+export { TraceStorage } from './TraceStorage';
+export type { ITraceStorage } from './TraceStorage';

package/dist/storage/index.js

@@ -0,0 +1 @@
+export { TraceStorage } from './TraceStorage';

package/dist/types.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Types for @zintrust/trace
+ * Sealed type definitions — no side effects.
+ */
+import type { IDatabase } from '@zintrust/core';
+export declare const EntryType: Readonly<{
+    readonly REQUEST: "request";
+    readonly QUERY: "query";
+    readonly EXCEPTION: "exception";
+    readonly LOG: "log";
+    readonly JOB: "job";
+    readonly CACHE: "cache";
+    readonly SCHEDULE: "schedule";
+    readonly MAIL: "mail";
+    readonly AUTH: "auth";
+    readonly EVENT: "event";
+    readonly MODEL: "model";
+    readonly NOTIFICATION: "notification";
+    readonly REDIS: "redis";
+    readonly GATE: "gate";
+    readonly MIDDLEWARE: "middleware";
+    readonly COMMAND: "command";
+    readonly BATCH: "batch";
+    readonly DUMP: "dump";
+    readonly VIEW: "view";
+    readonly CLIENT_REQUEST: "client_request";
+}>;
+export type EntryTypeValue = (typeof EntryType)[keyof typeof EntryType];
+export interface RequestContent {
+    method: string;
+    uri: string;
+    headers: Record<string, string>;
+    payload: Record<string, unknown>;
+    responseStatus: number;
+    responseHeaders: Record<string, string>;
+    duration: number;
+    memory: number | null;
+    middleware: string[];
+    hostname: string;
+    userId?: string;
+}
+export interface QueryContent {
+    connection: string;
+    sql: string;
+    time: number;
+    duration: number;
+    slow: boolean;
+    hash: string;
+    hostname: string;
+}
+export interface ExceptionContent {
+    class: string;
+    file: string;
+    line: number;
+    message: string;
+    trace: Array<{
+        file: string;
+        line: number;
+        function?: string;
+    }>;
+    linePreview: Record<string, string>;
+    occurrences: number;
+    hostname: string;
+    userId?: string;
+}
+export interface LogContent {
+    level: string;
+    message: string;
+    context?: Record<string, unknown>;
+    hostname: string;
+}
+export interface JobContent {
+    status: 'pending' | 'processed' | 'failed';
+    connection: string;
+    queue: string;
+    name: string;
+    tries?: number;
+    timeout?: number;
+    data?: unknown;
+    exception?: {
+        message: string;
+        trace: Array<{
+            file: string;
+            line: number;
+        }>;
+    };
+    hostname: string;
+}
+export interface CacheContent {
+    operation: 'get' | 'set' | 'delete' | 'clear' | 'has';
+    key: string;
+    hit?: boolean;
+    duration: number;
+    hostname: string;
+}
+export interface ScheduleContent {
+    name: string;
+    expression: string;
+    status: 'ran' | 'failed' | 'skipped';
+    duration: number;
+    output?: string;
+    hostname: string;
+}
+export interface MailContent {
+    to: string;
+    subject: string;
+    template?: string;
+    hostname: string;
+}
+export interface AuthContent {
+    event: 'login' | 'logout' | 'failed';
+    userId?: string;
+    hostname: string;
+}
+export interface EventContent {
+    name: string;
+    payload?: unknown;
+    listenerCount: number;
+    hostname: string;
+}
+export interface ModelContent {
+    action: 'create' | 'update' | 'delete';
+    model: string;
+    id?: string | number;
+    changes?: Record<string, unknown>;
+    hostname: string;
+}
+export interface NotificationContent {
+    channels: string[];
+    notifiable?: string;
+    notification: string;
+    hostname: string;
+}
+export interface RedisContent {
+    command: string;
+    duration: number;
+    hostname: string;
+}
+export interface GateContent {
+    ability: string;
+    result: 'allowed' | 'denied';
+    userId?: string;
+    subject?: string;
+    hostname: string;
+}
+export interface MiddlewareContent {
+    name: string;
+    event: 'before' | 'after';
+    duration?: number;
+    hostname: string;
+}
+export interface CommandContent {
+    name: string;
+    arguments: Record<string, unknown>;
+    exitCode: number;
+    duration: number;
+    output?: string;
+    hostname: string;
+}
+export interface BatchContent {
+    name: string;
+    total: number;
+    processed: number;
+    failed: number;
+    status: 'pending' | 'processing' | 'finished' | 'failed';
+    hostname: string;
+}
+export interface DumpContent {
+    value: unknown;
+    file?: string;
+    line?: number;
+    hostname: string;
+}
+export interface ViewContent {
+    template: string;
+    duration: number;
+    hostname: string;
+}
+export interface ClientRequestContent {
+    method: string;
+    url: string;
+    requestHeaders: Record<string, string>;
+    responseStatus: number;
+    duration: number;
+    hostname: string;
+}
+export interface ITraceEntry<T = unknown> {
+    uuid: string;
+    batchId: string;
+    familyHash?: string;
+    type: EntryTypeValue;
+    content: T;
+    tags: string[];
+    isLatest: boolean;
+    createdAt: number;
+}
+export interface QueryEntriesOptions {
+    type?: EntryTypeValue;
+    tag?: string;
+    batchId?: string;
+    from?: number;
+    to?: number;
+    page?: number;
+    perPage?: number;
+}
+export interface ITraceStorage {
+    writeEntry(entry: ITraceEntry): Promise<void>;
+    updateEntry(uuid: string, patch: Partial<Pick<ITraceEntry, 'content' | 'isLatest'>>): Promise<void>;
+    markFamilyStale(familyHash: string, exceptUuid: string): Promise<void>;
+    queryEntries(opts: QueryEntriesOptions): Promise<{
+        data: ITraceEntry[];
+        total: number;
+    }>;
+    getEntry(uuid: string): Promise<ITraceEntry | null>;
+    getBatch(batchId: string): Promise<ITraceEntry[]>;
+    prune(olderThanMs: number, keepExceptions?: boolean): Promise<number>;
+    clear(): Promise<void>;
+    getMonitoring(): Promise<string[]>;
+    addMonitoring(tag: string): Promise<void>;
+    removeMonitoring(tag: string): Promise<void>;
+    stats(): Promise<Record<EntryTypeValue, number>>;
+}
+export interface ITraceWatcherConfig {
+    storage: ITraceStorage;
+    config: ITraceConfig;
+    db?: IDatabase;
+    /** Optional: provide to allow HttpWatcher to register as global middleware. */
+    registerMiddleware?: (fn: (req: unknown, res: unknown, next: () => Promise<void>) => Promise<void>) => void;
+}
+export interface ITraceWatcher {
+    register(opts: ITraceWatcherConfig): () => void;
+}
+export type RedactionConfig = {
+    headers: string[];
+    body: string[];
+    query: string[];
+};
+export type WatcherToggles = {
+    request?: boolean;
+    query?: boolean;
+    exception?: boolean;
+    log?: boolean;
+    job?: boolean;
+    cache?: boolean;
+    schedule?: boolean;
+    mail?: boolean;
+    auth?: boolean;
+    event?: boolean;
+    model?: boolean;
+    notification?: boolean;
+    redis?: boolean;
+    gate?: boolean;
+    middleware?: boolean;
+    command?: boolean;
+    batch?: boolean;
+    dump?: boolean;
+    view?: boolean;
+    clientRequest?: boolean;
+};
+export interface ITraceConfig {
+    enabled: boolean;
+    connection?: string;
+    pruneAfterHours: number;
+    ignoreRoutes: string[];
+    slowQueryThreshold: number;
+    logMinLevel: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    watchers: WatcherToggles;
+    redaction: RedactionConfig;
+}
+export type TraceConfigOverrides = Partial<ITraceConfig>;

package/dist/types.js

@@ -0,0 +1,25 @@
+// ---------------------------------------------------------------------------
+// Entry types used by the trace event stream.
+// ---------------------------------------------------------------------------
+export const EntryType = Object.freeze({
+    REQUEST: 'request',
+    QUERY: 'query',
+    EXCEPTION: 'exception',
+    LOG: 'log',
+    JOB: 'job',
+    CACHE: 'cache',
+    SCHEDULE: 'schedule',
+    MAIL: 'mail',
+    AUTH: 'auth',
+    EVENT: 'event',
+    MODEL: 'model',
+    NOTIFICATION: 'notification',
+    REDIS: 'redis',
+    GATE: 'gate',
+    MIDDLEWARE: 'middleware',
+    COMMAND: 'command',
+    BATCH: 'batch',
+    DUMP: 'dump',
+    VIEW: 'view',
+    CLIENT_REQUEST: 'client_request',
+});

package/dist/ui.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Lightweight UI/dashboard entrypoint for @zintrust/trace.
+ *
+ * Import this subpath when you only need trace dashboard registration
+ * without pulling in the package root re-export surface.
+ */
+export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes';
+export type { TraceDashboardOptions, TraceDashboardRegistrationOptions } from './dashboard/routes';

package/dist/ui.js

@@ -0,0 +1,7 @@
+/**
+ * Lightweight UI/dashboard entrypoint for @zintrust/trace.
+ *
+ * Import this subpath when you only need trace dashboard registration
+ * without pulling in the package root re-export surface.
+ */
+export { registerTraceDashboard, registerTraceRoutes } from './dashboard/routes';

package/dist/utils/authTag.d.ts

@@ -0,0 +1,5 @@
+export declare const AuthTag: Readonly<{
+    append: (tags: string[]) => string[];
+    resolve: () => string | undefined;
+}>;
+export default AuthTag;

package/dist/utils/authTag.js

@@ -0,0 +1,18 @@
+import { TraceContext } from '../context';
+const resolveAuthTag = () => {
+    const userId = TraceContext.getUserId();
+    if (userId === undefined || userId === '')
+        return undefined;
+    return `Auth:${userId}`;
+};
+const appendAuthTag = (tags) => {
+    const authTag = resolveAuthTag();
+    if (authTag === undefined || tags.includes(authTag))
+        return tags;
+    return [...tags, authTag];
+};
+export const AuthTag = Object.freeze({
+    append: appendAuthTag,
+    resolve: resolveAuthTag,
+});
+export default AuthTag;

package/dist/utils/familyHash.d.ts

@@ -0,0 +1 @@
+export declare const familyHash: (input: string) => string;

package/dist/utils/familyHash.js

@@ -0,0 +1,8 @@
+export const familyHash = (input) => {
+    let hash = 2166136261;
+    for (let index = 0; index < input.length; index++) {
+        hash ^= input.codePointAt(index) ?? 0;
+        hash = (hash * 16777619) >>> 0;
+    }
+    return hash.toString(16).padStart(8, '0');
+};

package/dist/utils/redact.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Redaction helpers for @zintrust/trace watchers.
+ */
+export declare const redactHeaders: (headers: Record<string, string>, fields: string[]) => Record<string, string>;
+export declare const redactObject: (obj: Record<string, unknown>, fields: string[]) => Record<string, unknown>;
+export declare const redactString: (value: string, fields: string[]) => string;

package/dist/utils/redact.js

@@ -0,0 +1,49 @@
+/**
+ * Redaction helpers for @zintrust/trace watchers.
+ */
+const REDACTED = '[REDACTED]';
+const redactQuerySegment = (segment, fields) => {
+    const separatorIndex = segment.indexOf('=');
+    if (separatorIndex <= 0)
+        return segment;
+    const key = segment.slice(0, separatorIndex);
+    const value = segment.slice(separatorIndex + 1);
+    if (!fields.has(key.toLowerCase()))
+        return `${key}=${value}`;
+    return `${key}=${REDACTED}`;
+};
+export const redactHeaders = (headers, fields) => {
+    const lower = new Set(fields.map((f) => f.toLowerCase()));
+    const out = {};
+    for (const [k, v] of Object.entries(headers)) {
+        out[k] = lower.has(k.toLowerCase()) ? REDACTED : v;
+    }
+    return out;
+};
+export const redactObject = (obj, fields) => {
+    const lower = new Set(fields.map((f) => f.toLowerCase()));
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        out[k] = lower.has(k.toLowerCase()) ? REDACTED : v;
+    }
+    return out;
+};
+export const redactString = (value, fields) => {
+    const lower = new Set(fields.map((f) => f.toLowerCase()));
+    if (value === '')
+        return value;
+    let output = '';
+    let segmentStart = 0;
+    for (let index = 0; index <= value.length; index += 1) {
+        const isBoundary = index === value.length || value[index] === '&';
+        if (!isBoundary)
+            continue;
+        const segment = value.slice(segmentStart, index);
+        output += redactQuerySegment(segment, lower);
+        if (index < value.length) {
+            output += '&';
+        }
+        segmentStart = index + 1;
+    }
+    return output;
+};

package/dist/utils/requestFilter.d.ts

@@ -0,0 +1,4 @@
+export declare const RequestFilter: Readonly<{
+    matchesIgnoredPath: (path: string, ignoreRoutes: string[]) => boolean;
+    shouldIgnoreCurrentRequest: (ignoreRoutes: string[]) => boolean;
+}>;

package/dist/utils/requestFilter.js

@@ -0,0 +1,26 @@
+import { TraceContext } from '../context';
+const normalizePath = (input) => {
+    const trimmed = input.trim();
+    const [pathOnly] = trimmed.split('?');
+    if (!pathOnly || pathOnly === '')
+        return '/';
+    return pathOnly.startsWith('/') ? pathOnly : `/${pathOnly}`;
+};
+const matchesIgnoredPath = (path, ignoreRoutes) => {
+    const normalizedPath = normalizePath(path);
+    return ignoreRoutes.some((route) => {
+        const normalizedRoute = normalizePath(route);
+        return (normalizedPath === normalizedRoute ||
+            normalizedPath.startsWith(normalizedRoute.endsWith('/') ? normalizedRoute : `${normalizedRoute}/`));
+    });
+};
+const shouldIgnoreCurrentRequest = (ignoreRoutes) => {
+    const currentPath = TraceContext.getRequestPath();
+    if (typeof currentPath !== 'string' || currentPath === '')
+        return false;
+    return matchesIgnoredPath(currentPath, ignoreRoutes);
+};
+export const RequestFilter = Object.freeze({
+    matchesIgnoredPath,
+    shouldIgnoreCurrentRequest,
+});

package/dist/utils/stackFrame.d.ts

@@ -0,0 +1,6 @@
+type StackFrame = {
+    file: string;
+    line: number;
+};
+export declare const parseStackFrameLine: (line: string) => StackFrame | null;
+export {};

package/dist/utils/stackFrame.js

@@ -0,0 +1,38 @@
+const FRAME_PREFIX = 'at ';
+const parsePositiveInt = (value) => {
+    if (value === '')
+        return null;
+    for (const char of value) {
+        if (char < '0' || char > '9')
+            return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+};
+const parseFrameLocation = (value) => {
+    const columnSeparatorIndex = value.lastIndexOf(':');
+    if (columnSeparatorIndex <= 0)
+        return null;
+    const lineSeparatorIndex = value.lastIndexOf(':', columnSeparatorIndex - 1);
+    if (lineSeparatorIndex <= 0)
+        return null;
+    const file = value.slice(0, lineSeparatorIndex).trim();
+    const line = parsePositiveInt(value.slice(lineSeparatorIndex + 1, columnSeparatorIndex));
+    const column = parsePositiveInt(value.slice(columnSeparatorIndex + 1));
+    if (file === '' || line === null || column === null)
+        return null;
+    return { file, line };
+};
+export const parseStackFrameLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(FRAME_PREFIX))
+        return null;
+    const body = trimmed.slice(FRAME_PREFIX.length).trim();
+    if (body === '')
+        return null;
+    const wrappedStartIndex = body.lastIndexOf(' (');
+    if (wrappedStartIndex !== -1 && body.endsWith(')')) {
+        return parseFrameLocation(body.slice(wrappedStartIndex + 2, -1));
+    }
+    return parseFrameLocation(body);
+};