@typeslayer/analyze-trace 0.1.13 → 0.1.15

package/dist/index.js

@@ -1,1591 +0,0 @@
-// src/analyze-trace.ts
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile2, writeFile } from "fs/promises";
-import { join as join2 } from "path";
-
-// ../validate/dist/index.js
-import { z as z2 } from "zod/v4";
-import { z } from "zod/v4";
-import { z as z3 } from "zod/v4";
-var packageNameRegex = /\/node_modules\/((?:[^@][^/]+)|(?:@[^/]+\/[^/]+))/g;
-var typeId = z.number().int().positive().or(z.literal(-1));
-var position = z.object({
-  line: typeId,
-  character: z.number()
-});
-var absolutePath = z.string();
-var location = z.object({
-  path: absolutePath,
-  start: position,
-  end: position
-});
-var TRACE_JSON_FILENAME = "trace.json";
-var eventPhase = {
-  begin: "B",
-  end: "E",
-  complete: "X",
-  metadata: "M",
-  instantGlobal: "I"
-  // 'i' is instantThread
-};
-var instantScope = {
-  thread: "t",
-  global: "g",
-  process: "p"
-};
-var durationEvent = {
-  ph: z2.union([z2.literal(eventPhase.begin), z2.literal(eventPhase.end)])
-};
-var completeEvent = {
-  ph: z2.literal(eventPhase.complete),
-  dur: z2.number().positive()
-};
-var instantEvent = {
-  ph: z2.literal(eventPhase.instantGlobal)
-};
-var category = {
-  parse: {
-    cat: z2.literal("parse")
-  },
-  program: {
-    cat: z2.literal("program")
-  },
-  bind: {
-    cat: z2.literal("bind")
-  },
-  check: {
-    cat: z2.literal("check")
-  },
-  checkTypes: {
-    cat: z2.literal("checkTypes")
-  },
-  emit: {
-    cat: z2.literal("emit")
-  },
-  session: {
-    cat: z2.literal("session")
-  }
-};
-var eventCommon = {
-  pid: z2.number().int().positive(),
-  tid: z2.number().int().positive(),
-  ts: z2.number().positive()
-};
-var event_metadata__TracingStartedInBrowser = z2.object({
-  ...eventCommon,
-  cat: z2.literal("disabled-by-default-devtools.timeline"),
-  name: z2.literal("TracingStartedInBrowser"),
-  ph: z2.literal(eventPhase.metadata)
-}).strict();
-var event_metadata__process_name = z2.object({
-  ...eventCommon,
-  ph: z2.literal(eventPhase.metadata),
-  args: z2.object({
-    name: z2.literal("tsc")
-  }),
-  cat: z2.literal("__metadata"),
-  name: z2.literal("process_name")
-}).strict();
-var event_metadata__thread_name = z2.object({
-  ...eventCommon,
-  name: z2.literal("thread_name"),
-  cat: z2.literal("__metadata"),
-  ph: z2.literal(eventPhase.metadata),
-  args: z2.object({
-    name: z2.literal("Main")
-  })
-}).strict();
-var event_parse__createSourceFile = z2.object({
-  ...eventCommon,
-  ...category.parse,
-  ...durationEvent,
-  name: z2.literal("createSourceFile"),
-  args: z2.object({
-    path: absolutePath
-  })
-}).strict();
-var event_parse__parseJsonSourceFileConfigFileContent = z2.object({
-  ...eventCommon,
-  ...category.parse,
-  ...completeEvent,
-  name: z2.literal("parseJsonSourceFileConfigFileContent"),
-  args: z2.object({
-    path: absolutePath
-  })
-}).strict();
-var event_program__createProgram = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...durationEvent,
-  name: z2.literal("createProgram"),
-  args: z2.object({
-    configFilePath: absolutePath
-    // path to the tsconfig.json file
-  })
-}).strict();
-var event_program__findSourceFile = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("findSourceFile"),
-  dur: z2.number(),
-  args: z2.object({
-    fileName: absolutePath,
-    fileIncludeKind: z2.union([
-      z2.literal("RootFile"),
-      z2.literal("Import"),
-      z2.literal("TypeReferenceDirective"),
-      z2.literal("LibFile"),
-      z2.literal("LibReferenceDirective"),
-      z2.literal("AutomaticTypeDirectiveFile"),
-      z2.literal("ReferenceFile")
-    ])
-  })
-}).strict();
-var event_program__processRootFiles = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("processRootFiles"),
-  dur: z2.number(),
-  args: z2.object({ count: z2.number().int().positive() })
-}).strict();
-var event_program__processTypeReferenceDirective = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("processTypeReferenceDirective"),
-  dur: z2.number(),
-  args: z2.object({
-    directive: z2.string(),
-    hasResolved: z2.literal(true),
-    refKind: z2.number().int().positive(),
-    refPath: absolutePath.optional()
-  })
-}).strict();
-var event_program__processTypeReferences = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("processTypeReferences"),
-  dur: z2.number(),
-  args: z2.object({
-    count: z2.number().int().positive()
-  })
-}).strict();
-var event_program__resolveLibrary = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("resolveLibrary"),
-  args: z2.object({
-    resolveFrom: absolutePath
-  })
-}).strict();
-var event_program__resolveModuleNamesWorker = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("resolveModuleNamesWorker"),
-  args: z2.object({
-    containingFileName: absolutePath
-  })
-}).strict();
-var event_program__resolveTypeReferenceDirectiveNamesWorker = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("resolveTypeReferenceDirectiveNamesWorker"),
-  args: z2.object({
-    containingFileName: absolutePath
-  })
-}).strict();
-var event_program__shouldProgramCreateNewSourceFiles = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...instantEvent,
-  name: z2.literal("shouldProgramCreateNewSourceFiles"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    hasOldProgram: z2.boolean()
-  })
-}).strict();
-var event_program__tryReuseStructureFromOldProgram = z2.object({
-  ...eventCommon,
-  ...category.program,
-  ...completeEvent,
-  name: z2.literal("tryReuseStructureFromOldProgram"),
-  dur: z2.number(),
-  args: z2.object({})
-}).strict();
-var event_bind__bindSourceFile = z2.object({
-  ...eventCommon,
-  ...category.bind,
-  ...durationEvent,
-  name: z2.literal("bindSourceFile"),
-  args: z2.object({
-    path: absolutePath
-  })
-}).strict();
-var event_check__checkExpression = z2.object({
-  ...eventCommon,
-  ...category.check,
-  ...completeEvent,
-  name: z2.literal("checkExpression"),
-  dur: z2.number(),
-  args: z2.object({
-    kind: z2.number(),
-    pos: z2.number(),
-    end: z2.number(),
-    path: absolutePath.optional()
-  })
-}).strict();
-var event_check__checkSourceFile = z2.object({
-  ...eventCommon,
-  ...category.check,
-  ...durationEvent,
-  name: z2.literal("checkSourceFile"),
-  args: z2.object({
-    path: absolutePath
-  })
-}).strict();
-var event_check__checkVariableDeclaration = z2.object({
-  ...eventCommon,
-  ...category.check,
-  ...completeEvent,
-  name: z2.literal("checkVariableDeclaration"),
-  dur: z2.number(),
-  args: z2.object({
-    kind: z2.number(),
-    pos: z2.number(),
-    end: z2.number(),
-    path: absolutePath
-  })
-}).strict();
-var event_check__checkDeferredNode = z2.object({
-  ...eventCommon,
-  ...category.check,
-  ...completeEvent,
-  name: z2.literal("checkDeferredNode"),
-  dur: z2.number(),
-  args: z2.object({
-    kind: z2.number(),
-    pos: z2.number(),
-    end: z2.number(),
-    path: absolutePath
-  })
-}).strict();
-var event_check__checkSourceFileNodes = z2.object({
-  ...eventCommon,
-  ...category.check,
-  ...completeEvent,
-  name: z2.literal("checkSourceFileNodes"),
-  dur: z2.number(),
-  args: z2.object({
-    path: absolutePath
-  })
-}).strict();
-var event_checktypes__checkTypeParameterDeferred = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...completeEvent,
-  name: z2.literal("checkTypeParameterDeferred"),
-  dur: z2.number(),
-  args: z2.object({
-    parent: typeId,
-    id: typeId
-  })
-}).strict();
-var event_checktypes__getVariancesWorker = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...completeEvent,
-  name: z2.literal("getVariancesWorker"),
-  dur: z2.number(),
-  args: z2.object({
-    arity: z2.number().int().nonnegative(),
-    id: z2.number().int().positive(),
-    results: z2.object({
-      variances: z2.array(
-        z2.union([
-          z2.literal("[independent]"),
-          z2.literal("[independent] (unreliable)"),
-          z2.literal("[independent] (unmeasurable)"),
-          z2.literal("[bivariant]"),
-          z2.literal("[bivariant] (unreliable)"),
-          z2.literal("[bivariant] (unmeasurable)"),
-          z2.literal("in"),
-          z2.literal("in (unreliable)"),
-          z2.literal("in (unmeasurable)"),
-          z2.literal("out"),
-          z2.literal("out (unreliable)"),
-          z2.literal("out (unmeasurable)"),
-          z2.literal(
-            "in out"
-            /*burger*/
-          ),
-          z2.literal("in out (unreliable)"),
-          z2.literal("in out (unmeasurable)")
-        ])
-      )
-    })
-  })
-}).strict();
-var event_checktypes__structuredTypeRelatedTo = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...completeEvent,
-  name: z2.literal("structuredTypeRelatedTo"),
-  args: z2.object({
-    sourceId: typeId,
-    targetId: typeId
-  })
-}).strict();
-var event_checktypes__checkCrossProductUnion_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("checkCrossProductUnion_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    types: z2.array(typeId),
-    size: z2.number().int().positive()
-  })
-}).strict();
-var event_checktypes__checkTypeRelatedTo_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("checkTypeRelatedTo_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    sourceId: typeId,
-    targetId: typeId,
-    depth: z2.number().int().positive(),
-    targetDepth: z2.number().int().positive()
-  })
-}).strict();
-var event_checktypes__getTypeAtFlowNode_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("getTypeAtFlowNode_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    flowId: z2.number().int().positive()
-  })
-}).strict();
-var event_checktypes__instantiateType_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("instantiateType_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    typeId,
-    instantiationDepth: z2.number().int(),
-    instantiationCount: z2.number().int().positive()
-  })
-}).strict();
-var event_checktypes__recursiveTypeRelatedTo_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("recursiveTypeRelatedTo_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    sourceId: typeId,
-    sourceIdStack: z2.array(typeId),
-    targetId: typeId,
-    targetIdStack: z2.array(typeId),
-    depth: z2.number().int().positive(),
-    targetDepth: z2.number().int().positive()
-  })
-}).strict();
-var event_checktypes__removeSubtypes_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("removeSubtypes_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    typeIds: z2.array(typeId)
-  })
-}).strict();
-var event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("traceUnionsOrIntersectionsTooLarge_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    sourceId: typeId,
-    sourceSize: z2.number().int().positive(),
-    targetId: typeId,
-    targetSize: z2.number().int().positive(),
-    pos: z2.number().int().nonnegative().optional(),
-    end: z2.number().int().positive().optional()
-  })
-}).strict();
-var event_checktypes__typeRelatedToDiscriminatedType_DepthLimit = z2.object({
-  ...eventCommon,
-  ...category.checkTypes,
-  ...instantEvent,
-  name: z2.literal("typeRelatedToDiscriminatedType_DepthLimit"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    sourceId: typeId,
-    targetId: typeId,
-    numCombinations: z2.number().int().positive()
-  })
-}).strict();
-var depthLimits = [
-  event_checktypes__checkCrossProductUnion_DepthLimit,
-  event_checktypes__checkTypeRelatedTo_DepthLimit,
-  event_checktypes__getTypeAtFlowNode_DepthLimit,
-  event_checktypes__instantiateType_DepthLimit,
-  event_checktypes__recursiveTypeRelatedTo_DepthLimit,
-  event_checktypes__removeSubtypes_DepthLimit,
-  event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit,
-  event_checktypes__typeRelatedToDiscriminatedType_DepthLimit
-];
-var event_emit__emit = z2.object({
-  ...eventCommon,
-  ...category.emit,
-  ...durationEvent,
-  name: z2.literal("emit"),
-  args: z2.object({})
-  // for some reason, this is empty
-}).strict();
-var event_emit__emitBuildInfo = z2.object({
-  ...eventCommon,
-  ...category.emit,
-  ph: z2.union([
-    z2.literal(eventPhase.begin),
-    z2.literal(eventPhase.end),
-    z2.literal(eventPhase.complete)
-  ]),
-  dur: z2.number().positive().optional(),
-  name: z2.literal("emitBuildInfo"),
-  args: z2.union([
-    z2.object({}),
-    z2.object({
-      buildInfoPath: absolutePath
-    })
-  ])
-}).strict();
-var event_emit__emitDeclarationFileOrBundle = z2.object({
-  ...eventCommon,
-  ...category.emit,
-  ...completeEvent,
-  name: z2.literal("emitDeclarationFileOrBundle"),
-  dur: z2.number(),
-  args: z2.object({
-    declarationFilePath: absolutePath
-  })
-}).strict();
-var event_emit__emitJsFileOrBundle = z2.object({
-  ...eventCommon,
-  ...category.emit,
-  ...completeEvent,
-  name: z2.literal("emitJsFileOrBundle"),
-  dur: z2.number(),
-  args: z2.object({
-    jsFilePath: absolutePath
-  })
-}).strict();
-var event_emit__transformNodes = z2.object({
-  ...eventCommon,
-  ...category.emit,
-  ...completeEvent,
-  name: z2.literal("transformNodes"),
-  args: z2.object({
-    path: absolutePath
-  })
-}).strict();
-var event_session__cancellationThrown = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("cancellationThrown"),
-  args: z2.object({
-    kind: z2.union([
-      z2.literal("CancellationTokenObject"),
-      z2.literal("ThrotledCancellationToken")
-    ])
-  })
-}).strict();
-var event_session__commandCanceled = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("commandCanceled"),
-  args: z2.object({
-    seq: z2.number().int().nonnegative(),
-    command: z2.string()
-  })
-}).strict();
-var event_session__commandError = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("commandError"),
-  args: z2.object({
-    seq: z2.number().int().nonnegative(),
-    command: z2.string(),
-    message: z2.string()
-  })
-}).strict();
-var event_session__createConfiguredProject = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("createConfiguredProject"),
-  args: z2.object({
-    configFilePath: absolutePath
-  })
-}).strict();
-var event_session__createdDocumentRegistryBucket = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("createdDocumentRegistryBucket"),
-  args: z2.object({
-    configFilePath: absolutePath,
-    key: z2.string()
-  })
-}).strict();
-var event_session__documentRegistryBucketOverlap = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("documentRegistryBucketOverlap"),
-  args: z2.object({
-    path: absolutePath,
-    key1: z2.string(),
-    key2: z2.string()
-  })
-}).strict();
-var event_session__executeCommand = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...durationEvent,
-  name: z2.literal("executeCommand"),
-  args: z2.object({
-    seq: z2.number().int().nonnegative(),
-    command: z2.string()
-  })
-}).strict();
-var event_session__finishCachingPerDirectoryResolution = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("finishCachingPerDirectoryResolution"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ])
-}).strict();
-var event_session__getPackageJsonAutoImportProvider = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...completeEvent,
-  name: z2.literal("getPackageJsonAutoImportProvider")
-}).strict();
-var event_session__getUnresolvedImports = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...completeEvent,
-  name: z2.literal("getUnresolvedImports"),
-  args: z2.object({
-    count: z2.number().int().nonnegative()
-  })
-}).strict();
-var event_session__loadConfiguredProject = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...durationEvent,
-  name: z2.literal("loadConfiguredProject"),
-  args: z2.object({
-    configFilePath: absolutePath
-  })
-}).strict();
-var event_session__regionSemanticCheck = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...durationEvent,
-  name: z2.literal("regionSemanticCheck"),
-  args: z2.object({
-    file: absolutePath,
-    configFilePath: absolutePath
-  })
-}).strict();
-var event_session__request = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("request"),
-  args: z2.object({
-    seq: z2.number().int().nonnegative(),
-    command: z2.string()
-  })
-}).strict();
-var event_session__response = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("response"),
-  args: z2.object({
-    seq: z2.number().int().nonnegative(),
-    command: z2.string(),
-    success: z2.boolean()
-  })
-}).strict();
-var event_session__semanticCheck = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...durationEvent,
-  name: z2.literal("semanticCheck"),
-  args: z2.object({
-    file: absolutePath,
-    configFilePath: absolutePath
-  })
-}).strict();
-var event_session__stepAction = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("stepAction"),
-  s: z2.union([
-    z2.literal(instantScope.global),
-    z2.literal(instantScope.thread),
-    z2.literal(instantScope.process)
-  ]),
-  args: z2.object({
-    seq: z2.number().int().nonnegative()
-  })
-}).strict();
-var event_session__stepCanceled = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("stepCanceled"),
-  args: z2.object({
-    seq: z2.number().int().nonnegative(),
-    early: z2.literal(true).optional()
-  })
-}).strict();
-var event_session__stepError = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...instantEvent,
-  name: z2.literal("stepError"),
-  args: z2.object({
-    seq: z2.number().int().nonnegative(),
-    message: z2.string()
-  })
-}).strict();
-var event_session__suggestionCheck = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...durationEvent,
-  name: z2.literal("suggestionCheck"),
-  args: z2.object({
-    file: absolutePath,
-    configFilePath: absolutePath
-  })
-}).strict();
-var event_session__syntacticCheck = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...durationEvent,
-  name: z2.literal("syntacticCheck"),
-  args: z2.object({
-    file: absolutePath,
-    configFilePath: absolutePath
-  })
-}).strict();
-var event_session__updateGraph = z2.object({
-  ...eventCommon,
-  ...category.session,
-  ...durationEvent,
-  name: z2.literal("updateGraph"),
-  args: z2.object({
-    name: z2.string(),
-    kind: z2.union([
-      z2.literal(0),
-      //"Inferred
-      z2.literal(1),
-      // Configured"
-      z2.literal(2),
-      // "Inferred"
-      z2.literal(3),
-      // "External"
-      z2.literal(4),
-      // "AutoImportProvider"
-      z2.literal(5)
-      // "Auxiliary"
-    ])
-  })
-}).strict();
-var traceEvent = z2.discriminatedUnion(
-  "name",
-  [
-    event_metadata__TracingStartedInBrowser,
-    event_metadata__process_name,
-    event_metadata__thread_name,
-    event_parse__createSourceFile,
-    event_parse__parseJsonSourceFileConfigFileContent,
-    event_program__createProgram,
-    event_program__findSourceFile,
-    event_program__processRootFiles,
-    event_program__processTypeReferenceDirective,
-    event_program__processTypeReferences,
-    event_program__resolveLibrary,
-    event_program__resolveModuleNamesWorker,
-    event_program__resolveTypeReferenceDirectiveNamesWorker,
-    event_program__shouldProgramCreateNewSourceFiles,
-    event_program__tryReuseStructureFromOldProgram,
-    event_bind__bindSourceFile,
-    event_check__checkExpression,
-    event_check__checkSourceFile,
-    event_check__checkVariableDeclaration,
-    event_check__checkDeferredNode,
-    event_check__checkSourceFileNodes,
-    event_checktypes__checkTypeParameterDeferred,
-    event_checktypes__getVariancesWorker,
-    event_checktypes__structuredTypeRelatedTo,
-    ...depthLimits,
-    event_emit__emit,
-    event_emit__emitBuildInfo,
-    event_emit__emitDeclarationFileOrBundle,
-    event_emit__emitJsFileOrBundle,
-    event_emit__transformNodes,
-    event_session__cancellationThrown,
-    event_session__commandCanceled,
-    event_session__commandError,
-    event_session__createConfiguredProject,
-    event_session__createdDocumentRegistryBucket,
-    event_session__documentRegistryBucketOverlap,
-    event_session__executeCommand,
-    event_session__finishCachingPerDirectoryResolution,
-    event_session__getPackageJsonAutoImportProvider,
-    event_session__getUnresolvedImports,
-    event_session__loadConfiguredProject,
-    event_session__regionSemanticCheck,
-    event_session__request,
-    event_session__response,
-    event_session__semanticCheck,
-    event_session__stepAction,
-    event_session__stepCanceled,
-    event_session__stepError,
-    event_session__suggestionCheck,
-    event_session__syntacticCheck,
-    event_session__updateGraph
-  ],
-  {
-    // errorMap: (issue, ctx) => ({
-    // 	// prettier-ignore
-    // 	message: issue.code === "invalid_union_discriminator" ?
-    // 			`Invalid discriminator value. Expected ${issue.options.map(opt => `'${String(opt)}'`).join(' | ')}, got '${ctx.data.type}'.`
-    // 			: ctx.defaultError,
-    // }),
-  }
-);
-var traceJsonSchema = z2.array(traceEvent);
-var ALL_LIFE_IS_SUFFERING_THAT_BASKS_IN_NOTHINGNESS___ALL_LIFE_IS_TEMPORARY___WHAT_LASTS_IS_CONSCIOUSNESS = [{ id: 0, recursionId: -1, flags: [] }];
-var createTypeRegistry = (typesJson) => {
-  return ALL_LIFE_IS_SUFFERING_THAT_BASKS_IN_NOTHINGNESS___ALL_LIFE_IS_TEMPORARY___WHAT_LASTS_IS_CONSCIOUSNESS.concat(
-    typesJson
-  );
-};
-var TYPES_JSON_FILENAME = "types.json";
-var flag = z3.enum([
-  "Any",
-  "Unknown",
-  "String",
-  "Number",
-  "Boolean",
-  "Enum",
-  "BigInt",
-  "StringLiteral",
-  "NumberLiteral",
-  "BooleanLiteral",
-  "EnumLiteral",
-  "BigIntLiteral",
-  "ESSymbol",
-  "UniqueESSymbol",
-  "Void",
-  "Undefined",
-  "Null",
-  "Never",
-  "TypeParameter",
-  "Object",
-  "Union",
-  "Intersection",
-  "Index",
-  "IndexedAccess",
-  "Conditional",
-  "Substitution",
-  "NonPrimitive",
-  "TemplateLiteral",
-  "StringMapping",
-  "Reserved1",
-  "Reserved2",
-  "AnyOrUnknown",
-  "Nullable",
-  "Literal",
-  "Unit",
-  "Freshable",
-  "StringOrNumberLiteral",
-  "StringOrNumberLiteralOrUnique",
-  "DefinitelyFalsy",
-  "PossiblyFalsy",
-  "Intrinsic",
-  "StringLike",
-  "NumberLike",
-  "BigIntLike",
-  "BooleanLike",
-  "EnumLike",
-  "ESSymbolLike",
-  "VoidLike",
-  "Primitive",
-  "DefinitelyNonNullable",
-  "DisjointDomains",
-  "UnionOrIntersection",
-  "StructuredType",
-  "TypeVariable",
-  "InstantiableNonPrimitive",
-  "InstantiablePrimitive",
-  "Instantiable",
-  "StructuredOrInstantiable",
-  "ObjectFlagsType",
-  "Simplifiable",
-  "Singleton",
-  "Narrowable",
-  "IncludesMask",
-  "IncludesMissingType",
-  "IncludesNonWideningType",
-  "IncludesWildcard",
-  "IncludesEmptyObject",
-  "IncludesInstantiable",
-  "IncludesConstrainedTypeVariable",
-  "IncludesError",
-  "NotPrimitiveUnion"
-]);
-var resolvedType = z3.object({
-  id: typeId,
-  flags: z3.array(flag),
-  recursionId: z3.number().optional(),
-  intrinsicName: z3.enum([
-    "any",
-    "error",
-    "unresolved",
-    "unknown",
-    "true",
-    "false",
-    "never",
-    "void",
-    "symbol",
-    "bigint",
-    "null",
-    "undefined",
-    "intrinsic",
-    "object",
-    "boolean",
-    "number",
-    "string"
-  ]).optional(),
-  firstDeclaration: location.optional(),
-  referenceLocation: location.optional(),
-  destructuringPattern: location.optional(),
-  // TODO, awards for all of these
-  typeArguments: z3.array(typeId).optional(),
-  unionTypes: z3.array(typeId).optional(),
-  intersectionTypes: z3.array(typeId).optional(),
-  aliasTypeArguments: z3.array(typeId).optional(),
-  instantiatedType: typeId.optional(),
-  substitutionBaseType: typeId.optional(),
-  constraintType: typeId.optional(),
-  indexedAccessObjectType: typeId.optional(),
-  indexedAccessIndexType: typeId.optional(),
-  conditionalCheckType: typeId.optional(),
-  conditionalExtendsType: typeId.optional(),
-  conditionalTrueType: typeId.optional(),
-  conditionalFalseType: typeId.optional(),
-  keyofType: typeId.optional(),
-  aliasType: typeId.optional(),
-  evolvingArrayElementType: typeId.optional(),
-  evolvingArrayFinalType: typeId.optional(),
-  reverseMappedSourceType: typeId.optional(),
-  reverseMappedMappedType: typeId.optional(),
-  reverseMappedConstraintType: typeId.optional(),
-  isTuple: z3.literal(true).optional(),
-  symbolName: z3.string().optional(),
-  display: z3.string().optional()
-}).strict();
-var typesJsonSchema = z3.array(resolvedType);
-
-// src/constants.ts
-var ANALYZE_TRACE_FILENAME = "analyze-trace.json";
-
-// src/depth-limits.ts
-var createDepthLimits = (traceFile) => {
-  const limitNamesSet = new Set(
-    depthLimits.map((d) => d.shape.name)
-  );
-  const limitEvents = traceFile.filter((event) => limitNamesSet.has(event.name));
-  return {
-    checkCrossProductUnion_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__checkCrossProductUnion_DepthLimit.safeParse(event).success
-    ).sort((a, b) => a.args.size - b.args.size),
-    checkTypeRelatedTo_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__checkTypeRelatedTo_DepthLimit.safeParse(event).success
-    ).sort((a, b) => a.args.depth - b.args.depth),
-    getTypeAtFlowNode_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__getTypeAtFlowNode_DepthLimit.safeParse(event).success
-    ).sort((a, b) => a.args.flowId - b.args.flowId),
-    instantiateType_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__instantiateType_DepthLimit.safeParse(event).success
-    ).sort((a, b) => a.args.instantiationDepth - b.args.instantiationDepth),
-    recursiveTypeRelatedTo_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__recursiveTypeRelatedTo_DepthLimit.safeParse(event).success
-    ).sort((a, b) => a.args.depth - b.args.depth),
-    removeSubtypes_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__removeSubtypes_DepthLimit.safeParse(event).success
-    ),
-    traceUnionsOrIntersectionsTooLarge_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit.safeParse(
-        event
-      ).success
-    ).sort(
-      (a, b) => a.args.sourceSize * a.args.targetSize - b.args.sourceSize * b.args.targetSize
-    ),
-    typeRelatedToDiscriminatedType_DepthLimit: limitEvents.filter(
-      (event) => event_checktypes__typeRelatedToDiscriminatedType_DepthLimit.safeParse(
-        event
-      ).success
-    ).sort((a, b) => a.args.numCombinations - b.args.numCombinations)
-  };
-};
-
-// src/get-duplicate-node-modules.ts
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { join } from "path";
-async function getPackageVersion(packagePath2) {
-  const packageJsonPath = join(packagePath2, "package.json");
-  console.log("packageJsonPath", packageJsonPath);
-  if (!existsSync(packageJsonPath)) {
-    console.warn(
-      `Package.json not found at ${packageJsonPath}. This may not be a node module.`
-    );
-    return "unknown";
-  }
-  const jsonString = await readFile(packageJsonPath, "utf-8");
-  const jsonObj = JSON.parse(jsonString);
-  return jsonObj.version;
-}
-var getDuplicateNodeModules = async (nodeModulePaths2) => {
-  const duplicates = [];
-  for (const [packageName2, packagePaths] of Object.entries(nodeModulePaths2)) {
-    if (packagePaths.length < 2) {
-      continue;
-    }
-    const instances = [];
-    for (const packagePath2 of packagePaths) {
-      instances.push({
-        path: packagePath2,
-        version: await getPackageVersion(packagePath2)
-      });
-    }
-    duplicates.push({
-      name: packageName2,
-      instances
-    });
-  }
-  return duplicates;
-};
-
-// src/get-hotspots.ts
-import { normalize } from "path";
-var getHotspots = async (hotPathsTree, typesFile, options) => getHotspotsWorker({
-  span: hotPathsTree,
-  currentFile: void 0,
-  typeRegistry: createTypeRegistry(typesFile),
-  options
-});
-async function getHotspotsWorker({
-  span,
-  currentFile,
-  typeRegistry,
-  options
-}) {
-  if (span.event.cat === "check") {
-    currentFile = span.event.args.path;
-  }
-  const children = [];
-  if (span.children.length) {
-    const sortedChildren = span.children.sort(
-      (a, b) => b.duration - a.duration
-    );
-    for (const child of sortedChildren) {
-      children.push(
-        ...await getHotspotsWorker({
-          span: child,
-          currentFile,
-          typeRegistry,
-          options
-        })
-      );
-    }
-  }
-  if (span.event.name !== "root") {
-    const hotFrame = await makeHotFrame({
-      span,
-      children,
-      typeRegistry
-    });
-    if (hotFrame) {
-      return [hotFrame];
-    }
-  }
-  return children;
-}
-var notFound = {
-  children: [],
-  resolvedType: {
-    id: -1,
-    display: "[Type Not Found]",
-    flags: []
-  }
-};
-function getHotType({
-  id,
-  typeRegistry
-}) {
-  function worker(id2, ancestorIds) {
-    if (id2 === -1) {
-      return notFound;
-    }
-    const resolvedType2 = typeRegistry[id2];
-    if (!resolvedType2) {
-      throw new Error(`Type ${id2} not found`);
-    }
-    const children = [];
-    if (ancestorIds.indexOf(id2) < 0) {
-      ancestorIds.push(id2);
-      const properties = Object.keys(resolvedType2);
-      for (const property of properties) {
-        switch (property) {
-          case "aliasTypeArguments":
-          case "intersectionTypes":
-          case "typeArguments":
-          case "unionTypes": {
-            const typeIds = resolvedType2[property];
-            if (!Array.isArray(typeIds)) {
-              throw new Error(`Expected array for ${property}`);
-            }
-            for (const typeId2 of typeIds) {
-              const child = worker(typeId2, ancestorIds);
-              if (child) {
-                children.push(child);
-              }
-            }
-            continue;
-          }
-          case "aliasType":
-          case "conditionalCheckType":
-          case "conditionalExtendsType":
-          case "conditionalFalseType":
-          case "conditionalTrueType":
-          case "constraintType":
-          case "evolvingArrayElementType":
-          case "evolvingArrayFinalType":
-          case "indexedAccessIndexType":
-          case "indexedAccessObjectType":
-          case "instantiatedType":
-          case "keyofType":
-          case "reverseMappedConstraintType":
-          case "reverseMappedMappedType":
-          case "reverseMappedSourceType":
-          case "substitutionBaseType": {
-            const typeId2 = resolvedType2[property];
-            const child = worker(typeId2, ancestorIds);
-            if (child) {
-              children.push(child);
-            }
-            break;
-          }
-          case "destructuringPattern":
-          case "display":
-          case "firstDeclaration":
-          case "flags":
-          case "id":
-          case "intrinsicName":
-          case "isTuple":
-          case "recursionId":
-          case "referenceLocation":
-          case "symbolName":
-            break;
-          default:
-            property;
-            throw new Error(`Unexpected property ${property}`);
-        }
-      }
-      ancestorIds.pop();
-    }
-    return {
-      resolvedType: resolvedType2,
-      children
-    };
-  }
-  return worker(id, []);
-}
-async function makeHotFrame({
-  span,
-  children,
-  typeRegistry
-}) {
-  const { event, duration } = span;
-  const timeMs = Math.round(duration / 1e3);
-  switch (event.name) {
-    // case "findSourceFile":
-    //     TODO (https://github.com/microsoft/typescript-analyze-trace/issues/2)
-    case "checkSourceFile": {
-      const filePath = event.args.path;
-      const normalizedPath = normalize(filePath);
-      return {
-        description: `Check file ${normalizedPath}`,
-        timeMs,
-        path: normalizedPath,
-        children
-      };
-    }
-    case "structuredTypeRelatedTo":
-      return {
-        description: `Compare types ${event.args.sourceId} and ${event.args.targetId}`,
-        timeMs,
-        children,
-        types: [
-          getHotType({
-            id: event.args.sourceId,
-            typeRegistry
-          }),
-          getHotType({
-            id: event.args.targetId,
-            typeRegistry
-          })
-        ]
-      };
-    case "getVariancesWorker":
-      return {
-        description: `Determine variance of type ${event.args.id}`,
-        timeMs,
-        children,
-        types: [getHotType({ id: event.args.id, typeRegistry })]
-      };
-    case "checkExpression":
-    case "checkVariableDeclaration": {
-      const filePath = event.args.path;
-      const path = filePath ? { path: normalize(filePath) } : {};
-      const frame = {
-        description: event.name,
-        timeMs,
-        ...path,
-        children: []
-      };
-      return frame;
-    }
-    default:
-      return void 0;
-  }
-}
-
-// src/node-module-paths.ts
-function getNodeModulePaths(traceJson) {
-  const nodeModulePaths2 = {};
-  traceJson.forEach((event) => {
-    if (event.name !== "findSourceFile") {
-      return;
-    }
-    const path = event.args.fileName;
-    if (path) {
-      while (true) {
-        const match = packageNameRegex.exec(path);
-        if (!match) {
-          break;
-        }
-        const packageName2 = match[1];
-        const packagePath2 = match.input.substring(
-          0,
-          match.index + match[0].length
-        );
-        if (packageName2 in nodeModulePaths2) {
-          const paths = nodeModulePaths2[packageName2];
-          if (paths && paths.indexOf(packagePath2) < 0) {
-            paths.push(packagePath2);
-          }
-        } else {
-          nodeModulePaths2[packageName2] = [packagePath2];
-        }
-      }
-    }
-  });
-  return nodeModulePaths2;
-}
-
-// src/spans.ts
-function createSpans(traceFile) {
-  const unclosedStack = [];
-  const spans = [];
-  traceFile.forEach((event) => {
-    switch (event.ph) {
-      case eventPhase.begin:
-        unclosedStack.push(event);
-        return;
-      case eventPhase.end: {
-        const beginEvent = unclosedStack.pop();
-        if (!beginEvent) {
-          throw new Error("Unmatched end event");
-        }
-        spans.push({
-          event: beginEvent,
-          start: beginEvent.ts,
-          end: event.ts,
-          duration: event.ts - beginEvent.ts,
-          children: []
-        });
-        break;
-      }
-      case eventPhase.complete: {
-        const start = event.ts;
-        const duration = event.dur ?? 0;
-        spans.push({
-          event,
-          start,
-          end: start + duration,
-          duration,
-          children: []
-        });
-        break;
-      }
-      case eventPhase.instantGlobal:
-      case eventPhase.metadata:
-        return;
-      default:
-        event;
-    }
-  });
-  const parseResult2 = {
-    firstSpanStart: Math.min(...spans.map((span) => span.start)),
-    lastSpanEnd: Math.max(...spans.map((span) => span.end)),
-    spans,
-    unclosedStack
-  };
-  return parseResult2;
-}
-function createSpanTree(parseResult2, options) {
-  const { firstSpanStart, lastSpanEnd, spans, unclosedStack } = parseResult2;
-  for (let i = unclosedStack.length - 1; i >= 0; i--) {
-    const event = unclosedStack[i];
-    const start = event.ts;
-    const end = lastSpanEnd;
-    spans.push({
-      event,
-      start,
-      end,
-      duration: end - start,
-      children: []
-    });
-  }
-  spans.sort((a, b) => a.start - b.start);
-  const root = {
-    event: {
-      name: "root",
-      cat: "program"
-    },
-    start: firstSpanStart,
-    end: lastSpanEnd,
-    duration: lastSpanEnd - firstSpanStart,
-    children: []
-  };
-  const stack = [root];
-  for (const span of spans) {
-    let i = stack.length - 1;
-    for (; i > 0; i--) {
-      const curr = stack[i];
-      if (curr.end > span.start) {
-        stack.length = i + 1;
-        break;
-      }
-    }
-    const thresholdDuration = options.forceMillis * 1e3;
-    const isAboveThresholdDuration = span.duration >= thresholdDuration;
-    const parent = stack[i];
-    const parentDuration = parent.end - parent.start;
-    const isSignificantPortionOfParent = span.duration >= parentDuration * options.minSpanParentPercentage;
-    if (isAboveThresholdDuration || isSignificantPortionOfParent) {
-      parent.children.push(span);
-      stack.push(span);
-    }
-  }
-  return root;
-}
-
-// src/utils.ts
-import { existsSync as existsSync2 } from "fs";
-import { stat } from "fs/promises";
-import { z as z4 } from "zod/v4";
-var absolutePath2 = z4.string().refine(
-  (path) => {
-    return path.startsWith("/") || path.startsWith("C:\\") || path.startsWith("D:\\");
-  },
-  {
-    message: "Path must be absolute"
-  }
-);
-var project = z4.object({
-  configFilePath: absolutePath2.optional(),
-  tracePath: absolutePath2,
-  typesPath: absolutePath2
-});
-var projectResult = z4.object({
-  project,
-  stdout: z4.string(),
-  stderr: z4.string(),
-  exitCode: z4.number().optional(),
-  signal: z4.enum(["SIGINT", "SIGTERM"]).optional()
-});
-var hotType = z4.object({
-  resolvedType,
-  get children() {
-    return z4.array(hotType);
-  }
-});
-var hotSpot = z4.object({
-  description: z4.string(),
-  timeMs: z4.number(),
-  get children() {
-    return z4.array(hotSpot);
-  },
-  path: absolutePath2.optional(),
-  types: z4.array(hotType).optional(),
-  startLine: z4.number().optional(),
-  startChar: z4.number().optional(),
-  startOffset: z4.number().optional(),
-  endLine: z4.number().optional(),
-  endChar: z4.number().optional(),
-  endOffset: z4.number().optional()
-});
-var duplicatedPackageInstance = z4.object({
-  path: absolutePath2,
-  version: z4.string()
-});
-var duplicatedPackage = z4.object({
-  name: z4.string(),
-  instances: z4.array(duplicatedPackageInstance)
-});
-var rootSpan = z4.object({
-  name: z4.literal("root"),
-  cat: z4.literal("program")
-});
-var eventSpan = z4.object({
-  event: z4.union([traceEvent, rootSpan]),
-  start: z4.number(),
-  end: z4.number(),
-  duration: z4.number(),
-  get children() {
-    return z4.array(eventSpan);
-  }
-});
-var microseconds = z4.number();
-var packageName = z4.string();
-var packagePath = z4.string();
-var nodeModulePaths = z4.record(packageName, z4.array(packagePath));
-var parseResult = z4.object({
-  firstSpanStart: z4.number(),
-  lastSpanEnd: z4.number(),
-  spans: z4.array(eventSpan),
-  unclosedStack: z4.array(traceEvent)
-});
-var analyzeTraceOptions = z4.object({
-  /** Events of at least this duration (in milliseconds) will reported unconditionally */
-  forceMillis: z4.number(),
-  /** Events of less than this duration (in milliseconds) will suppressed unconditionally */
-  skipMillis: z4.number(),
-  /** Expand types when printing */
-  expandTypes: z4.boolean(),
-  /** force showing spans that are some percentage of their parent, independent of parent time */
-  minSpanParentPercentage: z4.number(),
-  /** the minimum number of emitted imports from a declaration file or bundle */
-  importExpressionThreshold: z4.number()
-});
-var isFile = async (path) => {
-  return stat(path).then((stats) => stats.isFile()).catch((_) => false);
-};
-var throwIfNotDirectory = async (path) => {
-  if (!existsSync2(path) || !(await stat(path))?.isDirectory()) {
-    throw new Error(`${path} is not a directory`);
-  }
-  return path;
-};
-var analyzeTraceResult = z4.object({
-  /** Events that were not closed */
-  unterminatedEvents: z4.array(traceEvent),
-  /** Hot spots in the trace */
-  hotSpots: z4.array(hotSpot),
-  /** Packages that are duplicated in the trace */
-  duplicatePackages: z4.array(duplicatedPackage),
-  /** Paths to all node modules used in the trace */
-  nodeModulePaths,
-  /** Depth limit events grouped by their event name */
-  depthLimits: z4.object({
-    checkCrossProductUnion_DepthLimit: z4.array(
-      event_checktypes__checkCrossProductUnion_DepthLimit
-    ),
-    checkTypeRelatedTo_DepthLimit: z4.array(
-      event_checktypes__checkTypeRelatedTo_DepthLimit
-    ),
-    getTypeAtFlowNode_DepthLimit: z4.array(
-      event_checktypes__getTypeAtFlowNode_DepthLimit
-    ),
-    instantiateType_DepthLimit: z4.array(
-      event_checktypes__instantiateType_DepthLimit
-    ),
-    recursiveTypeRelatedTo_DepthLimit: z4.array(
-      event_checktypes__recursiveTypeRelatedTo_DepthLimit
-    ),
-    removeSubtypes_DepthLimit: z4.array(
-      event_checktypes__removeSubtypes_DepthLimit
-    ),
-    traceUnionsOrIntersectionsTooLarge_DepthLimit: z4.array(
-      event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit
-    ),
-    typeRelatedToDiscriminatedType_DepthLimit: z4.array(
-      event_checktypes__typeRelatedToDiscriminatedType_DepthLimit
-    )
-  })
-});
-
-// src/analyze-trace.ts
-function validateOptions(options) {
-  if (options.forceMillis < options.skipMillis) {
-    throw new Error("forceMillis cannot be less than skipMillis");
-  }
-}
-var validateTraceDir = async (traceDir) => {
-  await throwIfNotDirectory(traceDir);
-  const typesFilePath = join2(traceDir, TYPES_JSON_FILENAME);
-  if (!existsSync3(typesFilePath)) {
-    throw new Error(
-      `types.json must exist in ${traceDir}. first run --generateTrace`
-    );
-  }
-  const typesFileJson = JSON.parse(await readFile2(typesFilePath, "utf8"));
-  const typesFile = typesJsonSchema.parse(typesFileJson);
-  const traceFilePath = join2(traceDir, TRACE_JSON_FILENAME);
-  if (!existsSync3(traceFilePath)) {
-    throw new Error(
-      `trace.json must exist in ${traceDir}. first run --generateTrace`
-    );
-  }
-  const traceFileJson = JSON.parse(await readFile2(traceFilePath, "utf8"));
-  const traceFile = traceJsonSchema.parse(traceFileJson);
-  return {
-    traceFile,
-    typesFile
-  };
-};
-var defaultOptions = {
-  forceMillis: 500,
-  skipMillis: 100,
-  expandTypes: true,
-  minSpanParentPercentage: 0.6,
-  importExpressionThreshold: 10
-};
-var analyzeTrace = async ({
-  traceDir,
-  options = defaultOptions
-}) => {
-  validateOptions(options);
-  const { traceFile, typesFile } = await validateTraceDir(traceDir);
-  const nodeModulePaths2 = getNodeModulePaths(traceFile);
-  const spans = createSpans(traceFile);
-  const hotPathsTree = createSpanTree(spans, options);
-  const result = {
-    nodeModulePaths: nodeModulePaths2,
-    unterminatedEvents: spans.unclosedStack.reverse(),
-    hotSpots: await getHotspots(hotPathsTree, typesFile, options),
-    duplicatePackages: await getDuplicateNodeModules(nodeModulePaths2),
-    depthLimits: createDepthLimits(traceFile)
-  };
-  await writeFile(
-    join2(traceDir, ANALYZE_TRACE_FILENAME),
-    JSON.stringify(result, null, 2)
-  );
-  return result;
-};
-export {
-  ANALYZE_TRACE_FILENAME,
-  absolutePath2 as absolutePath,
-  analyzeTrace,
-  analyzeTraceOptions,
-  analyzeTraceResult,
-  createDepthLimits,
-  defaultOptions,
-  duplicatedPackage,
-  duplicatedPackageInstance,
-  eventSpan,
-  hotSpot,
-  hotType,
-  isFile,
-  microseconds,
-  nodeModulePaths,
-  packageName,
-  packagePath,
-  parseResult,
-  project,
-  projectResult,
-  rootSpan,
-  throwIfNotDirectory,
-  validateOptions
-};
-//# sourceMappingURL=index.js.map