@forge-kit/plugin-source-map-prase 0.0.2 → 0.0.3

package/src/node/trace/resolve/context.ts

@@ -0,0 +1,59 @@
+import {readFile} from "node:fs/promises";
+import {basename} from "node:path";
+import {homedir} from "node:os";
+import type {ChainMapSlot} from "@/node/trace/core/base/types";
+import {
+    DEFAULT_CONTEXT_LINE_RADIUS,
+    buildChainStateFromSlots,
+    validateResolveInput,
+} from "../runner";
+import type {ResolveTaskContext, ResolveTraceInput} from "./types";
+
+const createChainSlotFromPath = async (filePath: string): Promise<ChainMapSlot> => {
+    const resolvedPath = filePath.startsWith("~/") ? `${homedir()}/${filePath.slice(2)}` : filePath
+    const mapFileName = basename(resolvedPath)
+    const slotId = `${mapFileName}-${Math.random().toString(36).slice(2, 8)}`
+
+    try {
+        const fileText = await readFile(resolvedPath, "utf8")
+        const rawSourceMap = JSON.parse(fileText)
+        if (!rawSourceMap || typeof rawSourceMap !== "object" || typeof rawSourceMap.mappings !== "string") {
+            throw new Error("invalid source-map json")
+        }
+        return {
+            id: slotId,
+            mapFileName,
+            mapFilePath: resolvedPath,
+            sourceMapRecord: {rawSourceMap, mapFileName},
+        }
+    } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error"
+        return {
+            id: slotId,
+            mapFileName,
+            mapFilePath: resolvedPath,
+            error: `${mapFileName}: ${message}`,
+        }
+    }
+}
+
+export const createResolveContext = async (parsed: ResolveTraceInput): Promise<ResolveTaskContext> => {
+    // 单次请求内统一读取并校验 map 文件，避免重复 IO。
+    const chainSlots = await Promise.all(parsed.mapFilePaths.map(createChainSlotFromPath))
+    const chainState = buildChainStateFromSlots(chainSlots)
+    const validated = validateResolveInput({
+        entryFileName: parsed.entryFileName,
+        entryLine: parsed.entryLine,
+        entryColumn: parsed.entryColumn,
+        contextLineRadius: parsed.contextLineRadius || String(DEFAULT_CONTEXT_LINE_RADIUS),
+        mapCount: chainState.sourceMapFileNames.length,
+    })
+    if (!validated.ok) throw new Error(validated.message)
+
+    return {
+        entry: validated.entry,
+        contextLineRadius: validated.contextLineRadius,
+        sourceMaps: chainState.sourceMaps,
+        sourceMapFileNames: chainState.sourceMapFileNames,
+    }
+}

package/src/node/trace/resolve/index.ts

@@ -0,0 +1,97 @@
+import {performance} from "node:perf_hooks";
+import {
+    buildTraceMetaOutput,
+    buildTraceSnippetOutput,
+    resolveTraceContextTask,
+} from "../runner";
+import {createResolveContext} from "./context";
+import {
+    createValidationMetaOutput,
+    isInputValidationMessage,
+    parseResolveInput,
+    toFallbackEntry,
+} from "./input";
+import {
+    assertSnippetPayloadWithinLimit,
+    estimateSnippetPayloadBytes,
+    parseMaxSnippetPayloadBytes,
+} from "./snippet-limit";
+import type {ProfileResolveTraceOutput, TraceProfilePhase} from "./types";
+
+const pushProfilePhase = (phases: TraceProfilePhase[], name: string, startedAt: number) => {
+    phases.push({name, durationMs: Number((performance.now() - startedAt).toFixed(2))})
+}
+
+export const resolveTrace = async (payloadText: string) => {
+    const parsed = parseResolveInput(payloadText)
+    try {
+        const resolveContext = await createResolveContext(parsed)
+        const resolved = await resolveTraceContextTask(resolveContext)
+        return buildTraceMetaOutput(resolved)
+    } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error"
+        if (isInputValidationMessage(message)) return createValidationMetaOutput(message)
+        return {
+            traceData: [{input: toFallbackEntry(parsed)}],
+            resolvedSourceMeta: null,
+            canFetchSourceSnippet: false,
+            message: `source-map trace failed: ${message}`,
+        }
+    }
+}
+
+export const getSourceSnippet = async (payloadText: string) => {
+    // 两阶段接口在无进程缓存模式下，第二阶段使用同一入参重新计算。
+    const parsed = parseResolveInput(payloadText)
+    const resolveContext = await createResolveContext(parsed)
+    const resolved = await resolveTraceContextTask(resolveContext)
+    const snippetOutput = buildTraceSnippetOutput({
+        contextLineRadius: resolveContext.contextLineRadius,
+        resolved,
+    })
+    assertSnippetPayloadWithinLimit(snippetOutput, parsed)
+    return snippetOutput
+}
+
+export const profileResolveTracePhases = async (payloadText: string): Promise<ProfileResolveTraceOutput> => {
+    const phases: TraceProfilePhase[] = []
+    const totalStart = performance.now()
+
+    const parseStart = performance.now()
+    const parsed = parseResolveInput(payloadText)
+    pushProfilePhase(phases, "parseResolveInput", parseStart)
+
+    const createContextStart = performance.now()
+    const resolveContext = await createResolveContext(parsed)
+    pushProfilePhase(phases, "createResolveContext", createContextStart)
+
+    const resolveTraceStart = performance.now()
+    const resolved = await resolveTraceContextTask(resolveContext)
+    pushProfilePhase(phases, "resolveTraceContextTask", resolveTraceStart)
+
+    const buildMetaStart = performance.now()
+    const metaOutput = buildTraceMetaOutput(resolved)
+    pushProfilePhase(phases, "buildTraceMetaOutput", buildMetaStart)
+
+    const buildSnippetStart = performance.now()
+    const snippetOutput = buildTraceSnippetOutput({
+        contextLineRadius: resolveContext.contextLineRadius,
+        resolved,
+    })
+    pushProfilePhase(phases, "buildTraceSnippetOutput", buildSnippetStart)
+
+    const estimateStart = performance.now()
+    const maxSnippetPayloadBytes = parseMaxSnippetPayloadBytes(parsed)
+    const snippetPayloadBytes = estimateSnippetPayloadBytes(snippetOutput)
+    pushProfilePhase(phases, "estimateSnippetPayloadBytes", estimateStart)
+
+    return {
+        phases,
+        totalMs: Number((performance.now() - totalStart).toFixed(2)),
+        traceHopCount: metaOutput.traceData.length,
+        resolvedSourceMetaExists: Boolean(metaOutput.resolvedSourceMeta),
+        snippetPayloadBytes,
+        maxSnippetPayloadBytes,
+        snippetPayloadWouldExceedLimit: snippetPayloadBytes > maxSnippetPayloadBytes,
+    }
+}

package/src/node/trace/resolve/input.ts

@@ -0,0 +1,35 @@
+import {DEFAULT_CONTEXT_LINE_RADIUS, type TraceMetaOutputState} from "../runner";
+import type {ResolveTraceInput} from "./types";
+
+const INPUT_VALIDATION_PATTERNS = ["请输入", "必须是", "未加载"]
+
+export const parseResolveInput = (payloadText: string): ResolveTraceInput => {
+    const parsed = JSON.parse(payloadText) as ResolveTraceInput
+    if (!parsed || typeof parsed !== "object") throw new Error("invalid resolveTrace payload")
+    if (!parsed.entryFileName) throw new Error("missing argument: entryFileName")
+    if (!parsed.entryLine) throw new Error("missing argument: entryLine")
+    if (!parsed.entryColumn) throw new Error("missing argument: entryColumn")
+    if (!Array.isArray(parsed.mapFilePaths) || parsed.mapFilePaths.length === 0) {
+        throw new Error("missing argument: mapFilePaths")
+    }
+    return {
+        ...parsed,
+        contextLineRadius: parsed.contextLineRadius || String(DEFAULT_CONTEXT_LINE_RADIUS),
+    }
+}
+
+export const isInputValidationMessage = (message: string) =>
+    INPUT_VALIDATION_PATTERNS.some((pattern) => message.includes(pattern))
+
+export const toFallbackEntry = (parsed: ResolveTraceInput) => ({
+    fileName: parsed.entryFileName,
+    lineNumber: Number(parsed.entryLine) || 1,
+    columnNumber: Number(parsed.entryColumn) || 0,
+})
+
+export const createValidationMetaOutput = (message: string): TraceMetaOutputState => ({
+    traceData: [],
+    resolvedSourceMeta: null,
+    canFetchSourceSnippet: false,
+    message,
+})

package/src/node/trace/resolve/snippet-limit.ts

@@ -0,0 +1,35 @@
+import type {TraceSnippetState} from "@/shared/trace-common";
+import type {ResolveTraceInput} from "./types";
+
+export const DEFAULT_MAX_SNIPPET_PAYLOAD_BYTES = 32 * 1024
+export const SNIPPET_PAYLOAD_EXCEEDED_ERROR = "SOURCE_SNIPPET_PAYLOAD_EXCEEDED: 返回体超出限制"
+const SNIPPET_PAYLOAD_OVERHEAD_BYTES = 512
+
+export const parseMaxSnippetPayloadBytes = (input: ResolveTraceInput) => {
+    if (!input.maxSnippetPayloadBytes?.trim()) return DEFAULT_MAX_SNIPPET_PAYLOAD_BYTES
+    const parsed = Number(input.maxSnippetPayloadBytes)
+    if (!Number.isInteger(parsed) || parsed <= 0) throw new Error("maxSnippetPayloadBytes 必须是大于 0 的整数。")
+    return parsed
+}
+
+export const estimateSnippetPayloadBytes = (snippet: TraceSnippetState) => {
+    const codeBytes = Buffer.byteLength(snippet.traceCode, "utf8")
+    const sourceFileBytes = snippet.resolvedSourceMeta?.sourceFile
+        ? Buffer.byteLength(snippet.resolvedSourceMeta.sourceFile, "utf8")
+        : 0
+    const highlightBytes = snippet.traceHighlightLines.reduce((total, line) => {
+        return total + Buffer.byteLength(String(line), "utf8") + 1
+    }, 0)
+    return codeBytes + sourceFileBytes + highlightBytes + SNIPPET_PAYLOAD_OVERHEAD_BYTES
+}
+
+export const assertSnippetPayloadWithinLimit = (
+    snippet: TraceSnippetState,
+    input: ResolveTraceInput,
+) => {
+    const maxSnippetPayloadBytes = parseMaxSnippetPayloadBytes(input)
+    const payloadBytes = estimateSnippetPayloadBytes(snippet)
+    if (payloadBytes > maxSnippetPayloadBytes) throw new Error(
+        `${SNIPPET_PAYLOAD_EXCEEDED_ERROR} (${payloadBytes} bytes > ${maxSnippetPayloadBytes} bytes)`,
+    )
+}

package/src/node/trace/resolve/types.ts

@@ -0,0 +1,37 @@
+import type {SourceMapRegistry, TraceHop} from "@/node/trace/core/base/types";
+import type {TraceLocation} from "@/shared/trace-common";
+import type {ResolveTraceInput} from "@/shared/trace-contract";
+export type {ResolveTraceInput};
+
+export interface ResolveTaskContext {
+    entry: TraceLocation
+    contextLineRadius: number
+    sourceMaps: SourceMapRegistry
+    sourceMapFileNames: string[]
+}
+
+export interface ResolvedTraceContext {
+    traceChain: TraceHop[]
+    sourceCode: {
+        code: string
+        sourceFile: string
+        lineNumber: number
+        columnNumber: number
+    } | null
+    lastResolved: TraceLocation | null
+}
+
+export interface TraceProfilePhase {
+    name: string
+    durationMs: number
+}
+
+export interface ProfileResolveTraceOutput {
+    phases: TraceProfilePhase[]
+    totalMs: number
+    traceHopCount: number
+    resolvedSourceMetaExists: boolean
+    snippetPayloadBytes: number
+    maxSnippetPayloadBytes: number
+    snippetPayloadWouldExceedLimit: boolean
+}

package/src/node/trace/runner.ts

@@ -0,0 +1,149 @@
+import {MAX_TRACE_DEPTH} from "@/node/trace/core/base/constants";
+import {buildRegistryFromChainSlots, getAutoEntryFileNameFromSlots} from "@/node/trace/core/domain/chain-slots";
+import {resolveSourceCodeFromTrace, getLastResolvedOutput} from "@/node/trace/core/domain/source-content";
+import {resolveTraceBySourceMaps} from "@/node/trace/core/domain/trace-resolver";
+import {toDisplayLocation, createCodeExcerpt} from "@/node/trace/core/domain/view-model";
+import type {
+    ChainMapSlot,
+    SourceMapRegistry,
+    TraceHop,
+} from "@/node/trace/core/base/types";
+import {
+    DEFAULT_CONTEXT_LINE_RADIUS,
+    createInitialOutputState,
+    patchOutputMessage,
+    validateResolveInput,
+} from "@/shared/trace-common";
+import type {
+    TraceMetaOutputState as SharedTraceMetaOutputState,
+    TraceOutputState as SharedTraceOutputState,
+    TraceSnippetState,
+} from "@/shared/trace-common";
+import type {ResolvedTraceContext, ResolveTaskContext} from "./resolve/types";
+
+export type TraceOutputState = SharedTraceOutputState<TraceHop>
+export type TraceMetaOutputState = SharedTraceMetaOutputState<TraceHop>
+
+export interface SourceMapChainState {
+    sourceMaps: SourceMapRegistry
+    sourceMapFileNames: string[]
+    chainMapSlots: ChainMapSlot[]
+    entryFileName: string
+}
+
+interface BuildTraceSnippetOutputInput {
+    contextLineRadius: number
+    resolved: ResolvedTraceContext
+}
+
+export const buildChainStateFromSlots = (slots: ChainMapSlot[]): SourceMapChainState => {
+    const {registry, orderedMapFileNames} = buildRegistryFromChainSlots(slots)
+    return {
+        sourceMaps: registry,
+        sourceMapFileNames: orderedMapFileNames,
+        chainMapSlots: slots,
+        entryFileName: getAutoEntryFileNameFromSlots(slots),
+    }
+}
+
+export const resolveTraceContextTask = async (context: ResolveTaskContext): Promise<ResolvedTraceContext> => {
+    const traceChain = await resolveTraceBySourceMaps({
+        entry: context.entry,
+        sourceMaps: context.sourceMaps,
+        orderedMapFileNames: context.sourceMapFileNames,
+        options: {maxDepth: MAX_TRACE_DEPTH},
+    })
+
+    const sourceCode = resolveSourceCodeFromTrace(traceChain, context.sourceMaps, {
+        onlyLastMap: true,
+        lastMapFileName: context.sourceMapFileNames[context.sourceMapFileNames.length - 1],
+    })
+
+    return {
+        traceChain,
+        sourceCode,
+        lastResolved: getLastResolvedOutput(traceChain),
+    }
+}
+
+export const buildTraceMetaOutput = (resolved: ResolvedTraceContext): TraceMetaOutputState => {
+    if (resolved.sourceCode) {
+        // 第一阶段只返回元信息；大段源码由第二阶段接口按需获取。
+        return {
+            traceData: resolved.traceChain,
+            resolvedSourceMeta: {
+                sourceFile: resolved.sourceCode.sourceFile,
+                lineNumber: resolved.sourceCode.lineNumber,
+                columnNumber: resolved.sourceCode.columnNumber,
+            },
+            canFetchSourceSnippet: true,
+            message: "已定位到源码位置，开始加载源码片段。",
+        }
+    }
+
+    if (resolved.lastResolved) {
+        const display = toDisplayLocation(resolved.lastResolved)
+        return {
+            traceData: resolved.traceChain,
+            resolvedSourceMeta: {
+                sourceFile: display.fileName,
+                lineNumber: display.lineNumber,
+                columnNumber: display.columnNumber,
+            },
+            canFetchSourceSnippet: false,
+            message: "当前 map 不包含 sourcesContent，无法直接渲染源码内容。",
+        }
+    }
+
+    return {
+        traceData: resolved.traceChain,
+        resolvedSourceMeta: null,
+        canFetchSourceSnippet: false,
+        message: "未命中映射，未定位到源码位置。",
+    }
+}
+
+export const buildTraceSnippetOutput = (input: BuildTraceSnippetOutputInput): TraceSnippetState => {
+    const {contextLineRadius, resolved} = input
+    if (resolved.sourceCode) {
+        const excerpt = createCodeExcerpt({
+            fullCode: resolved.sourceCode.code,
+            targetLine: resolved.sourceCode.lineNumber,
+            radius: contextLineRadius,
+            targetColumn: resolved.sourceCode.columnNumber,
+        })
+        return {
+            traceCode: excerpt.code,
+            resolvedSourceMeta: {
+                sourceFile: resolved.sourceCode.sourceFile,
+                lineNumber: resolved.sourceCode.lineNumber,
+                columnNumber: resolved.sourceCode.columnNumber,
+            },
+            traceHighlightLines: [excerpt.highlightLine],
+        }
+    }
+
+    if (resolved.lastResolved) {
+        const display = toDisplayLocation(resolved.lastResolved)
+        return {
+            traceCode: [
+                `已定位到源码位置：${display.fileName}:${display.lineNumber}:${display.columnNumber}`,
+                "当前 map 不包含 sourcesContent，无法直接渲染源码内容。",
+            ].join("\n"),
+            resolvedSourceMeta: {
+                sourceFile: display.fileName,
+                lineNumber: display.lineNumber,
+                columnNumber: display.columnNumber,
+            },
+            traceHighlightLines: [],
+        }
+    }
+
+    return {
+        traceCode: "未命中映射，未定位到源码位置。",
+        resolvedSourceMeta: null,
+        traceHighlightLines: [],
+    }
+}
+
+export {DEFAULT_CONTEXT_LINE_RADIUS, createInitialOutputState, patchOutputMessage, validateResolveInput}

package/src/shared/trace-common.ts

@@ -0,0 +1,104 @@
+export const DEFAULT_CONTEXT_LINE_RADIUS = 3
+
+export interface TraceLocation {
+    fileName: string
+    lineNumber: number
+    columnNumber: number
+}
+
+export interface ResolvedSourceMeta {
+    sourceFile: string
+    lineNumber: number
+    columnNumber: number
+}
+
+export interface TraceSnippetState {
+    traceCode: string
+    resolvedSourceMeta: ResolvedSourceMeta | null
+    traceHighlightLines: number[]
+}
+
+export interface TraceMetaOutputState<TTraceHop = unknown> {
+    traceData: TTraceHop[]
+    resolvedSourceMeta: ResolvedSourceMeta | null
+    canFetchSourceSnippet: boolean
+    message: string
+}
+
+export interface ResolveInputConfig {
+    entryFileName: string
+    entryLine: string
+    entryColumn: string
+    contextLineRadius: string
+    mapCount: number
+}
+
+export type ResolveInputValidation =
+    | { ok: true; entry: TraceLocation; contextLineRadius: number }
+    | { ok: false; message: string }
+
+export interface TraceOutputState<TTraceHop = unknown> {
+    traceData: TTraceHop[]
+    traceCode: string
+    resolvedSourceMeta: ResolvedSourceMeta | null
+    traceHighlightLines: number[]
+}
+
+export const createInitialOutputState = <TTraceHop = unknown>(): TraceOutputState<TTraceHop> => {
+    return {
+        traceData: [],
+        traceCode: "请先上传一个或多个 .map 文件。",
+        resolvedSourceMeta: null,
+        traceHighlightLines: [],
+    }
+}
+
+export const patchOutputMessage = <TTraceHop = unknown>(
+    prev: TraceOutputState<TTraceHop>,
+    message: string,
+): TraceOutputState<TTraceHop> => {
+    return {
+        ...prev,
+        traceCode: message,
+        traceHighlightLines: [],
+    }
+}
+
+export const validateResolveInput = (config: ResolveInputConfig): ResolveInputValidation => {
+    const parsedLine = Number(config.entryLine)
+    const parsedColumn = Number(config.entryColumn)
+    const parsedContextLineRadius = Number(config.contextLineRadius)
+    const normalizedFileName = config.entryFileName.replace(/\\/g, "/").trim()
+
+    if (!normalizedFileName) {
+        return {ok: false, message: "请输入入口文件名，例如 index.js"}
+    }
+    if (!config.entryLine.trim()) {
+        return {ok: false, message: "请输入入口行号（1-based）。"}
+    }
+    if (!config.entryColumn.trim()) {
+        return {ok: false, message: "请输入入口列号（0-based）。"}
+    }
+    if (!Number.isInteger(parsedLine) || parsedLine < 1) {
+        return {ok: false, message: "行号必须是大于等于 1 的整数。"}
+    }
+    if (!Number.isInteger(parsedColumn) || parsedColumn < 0) {
+        return {ok: false, message: "列号必须是大于等于 0 的整数。"}
+    }
+    if (!Number.isInteger(parsedContextLineRadius) || parsedContextLineRadius < 0) {
+        return {ok: false, message: "上下文行数必须是大于等于 0 的整数。"}
+    }
+    if (config.mapCount === 0) {
+        return {ok: false, message: "未加载可用 map 文件，请先上传。"}
+    }
+
+    return {
+        ok: true,
+        entry: {
+            fileName: normalizedFileName,
+            lineNumber: parsedLine,
+            columnNumber: parsedColumn,
+        },
+        contextLineRadius: parsedContextLineRadius,
+    }
+}

package/src/shared/trace-contract.ts

@@ -0,0 +1,29 @@
+import type {ResolvedSourceMeta, TraceLocation} from "@/shared/trace-common";
+
+export interface ResolveTraceInput {
+    entryFileName: string
+    entryLine: string
+    entryColumn: string
+    contextLineRadius?: string
+    mapFilePaths: string[]
+    maxSnippetPayloadBytes?: string
+}
+
+export interface TraceHopPayload {
+    input: TraceLocation
+    output?: TraceLocation
+    mapFileName?: string
+}
+
+export interface ResolveTraceMetaOutput {
+    traceData: TraceHopPayload[]
+    resolvedSourceMeta: ResolvedSourceMeta | null
+    canFetchSourceSnippet: boolean
+    message: string
+}
+
+export interface ResolveTraceSnippetOutput {
+    traceCode: string
+    resolvedSourceMeta: ResolvedSourceMeta | null
+    traceHighlightLines: number[]
+}

package/src/types.ts

@@ -0,0 +1,19 @@
+export type {
+    ResolveTraceInput,
+    ResolveTraceMetaOutput,
+    ResolveTraceSnippetOutput,
+} from "@/shared/trace-contract";
+
+export interface MapInputConfig {
+    entryLine: string
+    entryColumn: string
+    contextLineRadius: string
+}
+
+export interface ForgeKitBridge {
+    applyNodeMethod?: (method: string, ...args: string[]) => Promise<unknown>
+    openFileDialog?: (options: {
+        multiple?: boolean
+        filters?: {name: string; extensions: string[]}[]
+    }) => Promise<string | string[] | null>
+}

package/src/utils/trace-ui/index.ts

@@ -0,0 +1,12 @@
+export {SourceMapUtils} from "./state"
+
+export type {
+    TraceOutputState,
+    SourceMapChainState,
+    TraceDisplayHop,
+    ResolveInputConfig,
+    ChainMapSlot,
+    TraceLocation,
+    TraceHop,
+    ResolvedSourceMeta,
+} from "./state"

package/src/utils/trace-ui/state.ts

@@ -0,0 +1,81 @@
+import {
+    DEFAULT_CONTEXT_LINE_RADIUS,
+    createInitialOutputState,
+    patchOutputMessage,
+    validateResolveInput,
+} from "@/shared/trace-common";
+import type {
+    ResolveInputConfig,
+    ResolveInputValidation,
+    TraceLocation,
+    TraceOutputState as SharedTraceOutputState,
+} from "@/shared/trace-common";
+export type {ResolveInputConfig, ResolvedSourceMeta, TraceLocation} from "@/shared/trace-common";
+
+export interface TraceHop {
+    input: TraceLocation
+    output?: TraceLocation
+    mapFileName?: string
+}
+
+export type TraceOutputState = SharedTraceOutputState<TraceHop>
+
+export interface SourceMapChainState {
+    chainMapSlots: ChainMapSlot[]
+    entryFileName: string
+}
+
+export interface ChainMapSlot {
+    id: string
+    mapFileName: string
+    mapFilePath?: string
+    error?: string
+}
+
+export interface TraceDisplayHop {
+    input: TraceLocation
+    output?: TraceLocation
+    mapFileName?: string
+}
+
+export class SourceMapUtils {
+    static readonly DEFAULT_CONTEXT_LINE_RADIUS = DEFAULT_CONTEXT_LINE_RADIUS
+
+    static createInitialOutputState(): TraceOutputState {
+        return createInitialOutputState<TraceHop>()
+    }
+
+    static patchOutputMessage(prev: TraceOutputState, message: string): TraceOutputState {
+        return patchOutputMessage(prev, message)
+    }
+
+    static removeChainSlot(slots: ChainMapSlot[], slotId: string): ChainMapSlot[] {
+        return slots.filter((item) => item.id !== slotId)
+    }
+
+    static reorderChainSlots(slots: ChainMapSlot[], nextIds: string[]): ChainMapSlot[] {
+        const idOrder = new Map(nextIds.map((id, index) => [id, index]))
+        return [...slots].sort((a, b) => {
+            const aIndex = idOrder.get(a.id) ?? Number.MAX_SAFE_INTEGER
+            const bIndex = idOrder.get(b.id) ?? Number.MAX_SAFE_INTEGER
+            return aIndex - bIndex
+        })
+    }
+
+    static mapTraceForDisplay(traceData: TraceHop[]): TraceDisplayHop[] {
+        return traceData.map((item) => {
+            let output: TraceLocation | undefined
+            if (item.output) output = {...item.output}
+            return {
+                input: {...item.input},
+                output,
+                mapFileName: item.mapFileName,
+            }
+        })
+    }
+
+    static validateResolveInput(config: ResolveInputConfig): ResolveInputValidation {
+        return validateResolveInput(config)
+    }
+
+}