@typeslayer/analyze-trace 0.1.12 → 0.1.14

package/dist/index.js

@@ -2,19 +2,480 @@
 import { existsSync as existsSync3 } from "fs";
 import { readFile as readFile2, writeFile } from "fs/promises";
 import { join as join2 } from "path";
-import {
-  TRACE_JSON_FILENAME,
-  TYPES_JSON_FILENAME,
-  traceJsonSchema,
-  typesJsonSchema
-} from "@typeslayer/validate";
 
-// src/constants.ts
-var ANALYZE_TRACE_FILENAME = "analyze-trace.json";
-
-// src/depth-limits.ts
-import {
-  depthLimits,
+// ../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,
@@ -23,7 +484,489 @@ import {
   event_checktypes__removeSubtypes_DepthLimit,
   event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit,
   event_checktypes__typeRelatedToDiscriminatedType_DepthLimit
-} from "@typeslayer/validate";
+];
+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)
@@ -103,9 +1046,6 @@ var getDuplicateNodeModules = async (nodeModulePaths2) => {
 
 // src/get-hotspots.ts
 import { normalize } from "path";
-import {
-  createTypeRegistry
-} from "@typeslayer/validate";
 var getHotspots = async (hotPathsTree, typesFile, options) => getHotspotsWorker({
   span: hotPathsTree,
   currentFile: void 0,
@@ -183,8 +1123,8 @@ function getHotType({
             if (!Array.isArray(typeIds)) {
               throw new Error(`Expected array for ${property}`);
             }
-            for (const typeId of typeIds) {
-              const child = worker(typeId, ancestorIds);
+            for (const typeId2 of typeIds) {
+              const child = worker(typeId2, ancestorIds);
               if (child) {
                 children.push(child);
               }
@@ -207,8 +1147,8 @@ function getHotType({
           case "reverseMappedMappedType":
           case "reverseMappedSourceType":
           case "substitutionBaseType": {
-            const typeId = resolvedType2[property];
-            const child = worker(typeId, ancestorIds);
+            const typeId2 = resolvedType2[property];
+            const child = worker(typeId2, ancestorIds);
             if (child) {
               children.push(child);
             }
@@ -300,9 +1240,6 @@ async function makeHotFrame({
 }
 
 // src/node-module-paths.ts
-import {
-  packageNameRegex
-} from "@typeslayer/validate";
 function getNodeModulePaths(traceJson) {
   const nodeModulePaths2 = {};
   traceJson.forEach((event) => {
@@ -336,9 +1273,6 @@ function getNodeModulePaths(traceJson) {
 }
 
 // src/spans.ts
-import {
-  eventPhase
-} from "@typeslayer/validate";
 function createSpans(traceFile) {
   const unclosedStack = [];
   const spans = [];
@@ -439,20 +1373,8 @@ function createSpanTree(parseResult2, options) {
 // src/utils.ts
 import { existsSync as existsSync2 } from "fs";
 import { stat } from "fs/promises";
-import {
-  event_checktypes__checkCrossProductUnion_DepthLimit as event_checktypes__checkCrossProductUnion_DepthLimit2,
-  event_checktypes__checkTypeRelatedTo_DepthLimit as event_checktypes__checkTypeRelatedTo_DepthLimit2,
-  event_checktypes__getTypeAtFlowNode_DepthLimit as event_checktypes__getTypeAtFlowNode_DepthLimit2,
-  event_checktypes__instantiateType_DepthLimit as event_checktypes__instantiateType_DepthLimit2,
-  event_checktypes__recursiveTypeRelatedTo_DepthLimit as event_checktypes__recursiveTypeRelatedTo_DepthLimit2,
-  event_checktypes__removeSubtypes_DepthLimit as event_checktypes__removeSubtypes_DepthLimit2,
-  event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit as event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit2,
-  event_checktypes__typeRelatedToDiscriminatedType_DepthLimit as event_checktypes__typeRelatedToDiscriminatedType_DepthLimit2,
-  resolvedType,
-  traceEvent
-} from "@typeslayer/validate";
-import { z } from "zod/v4";
-var absolutePath = z.string().refine(
+import { z as z4 } from "zod/v4";
+var absolutePath2 = z4.string().refine(
   (path) => {
     return path.startsWith("/") || path.startsWith("C:\\") || path.startsWith("D:\\");
   },
@@ -460,81 +1382,81 @@ var absolutePath = z.string().refine(
     message: "Path must be absolute"
   }
 );
-var project = z.object({
-  configFilePath: absolutePath.optional(),
-  tracePath: absolutePath,
-  typesPath: absolutePath
+var project = z4.object({
+  configFilePath: absolutePath2.optional(),
+  tracePath: absolutePath2,
+  typesPath: absolutePath2
 });
-var projectResult = z.object({
+var projectResult = z4.object({
   project,
-  stdout: z.string(),
-  stderr: z.string(),
-  exitCode: z.number().optional(),
-  signal: z.enum(["SIGINT", "SIGTERM"]).optional()
+  stdout: z4.string(),
+  stderr: z4.string(),
+  exitCode: z4.number().optional(),
+  signal: z4.enum(["SIGINT", "SIGTERM"]).optional()
 });
-var hotType = z.object({
+var hotType = z4.object({
   resolvedType,
   get children() {
-    return z.array(hotType);
+    return z4.array(hotType);
   }
 });
-var hotSpot = z.object({
-  description: z.string(),
-  timeMs: z.number(),
+var hotSpot = z4.object({
+  description: z4.string(),
+  timeMs: z4.number(),
   get children() {
-    return z.array(hotSpot);
+    return z4.array(hotSpot);
   },
-  path: absolutePath.optional(),
-  types: z.array(hotType).optional(),
-  startLine: z.number().optional(),
-  startChar: z.number().optional(),
-  startOffset: z.number().optional(),
-  endLine: z.number().optional(),
-  endChar: z.number().optional(),
-  endOffset: z.number().optional()
+  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 = z.object({
-  path: absolutePath,
-  version: z.string()
+var duplicatedPackageInstance = z4.object({
+  path: absolutePath2,
+  version: z4.string()
 });
-var duplicatedPackage = z.object({
-  name: z.string(),
-  instances: z.array(duplicatedPackageInstance)
+var duplicatedPackage = z4.object({
+  name: z4.string(),
+  instances: z4.array(duplicatedPackageInstance)
 });
-var rootSpan = z.object({
-  name: z.literal("root"),
-  cat: z.literal("program")
+var rootSpan = z4.object({
+  name: z4.literal("root"),
+  cat: z4.literal("program")
 });
-var eventSpan = z.object({
-  event: z.union([traceEvent, rootSpan]),
-  start: z.number(),
-  end: z.number(),
-  duration: z.number(),
+var eventSpan = z4.object({
+  event: z4.union([traceEvent, rootSpan]),
+  start: z4.number(),
+  end: z4.number(),
+  duration: z4.number(),
   get children() {
-    return z.array(eventSpan);
+    return z4.array(eventSpan);
   }
 });
-var microseconds = z.number();
-var packageName = z.string();
-var packagePath = z.string();
-var nodeModulePaths = z.record(packageName, z.array(packagePath));
-var parseResult = z.object({
-  firstSpanStart: z.number(),
-  lastSpanEnd: z.number(),
-  spans: z.array(eventSpan),
-  unclosedStack: z.array(traceEvent)
+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 = z.object({
+var analyzeTraceOptions = z4.object({
   /** Events of at least this duration (in milliseconds) will reported unconditionally */
-  forceMillis: z.number(),
+  forceMillis: z4.number(),
   /** Events of less than this duration (in milliseconds) will suppressed unconditionally */
-  skipMillis: z.number(),
+  skipMillis: z4.number(),
   /** Expand types when printing */
-  expandTypes: z.boolean(),
+  expandTypes: z4.boolean(),
   /** force showing spans that are some percentage of their parent, independent of parent time */
-  minSpanParentPercentage: z.number(),
+  minSpanParentPercentage: z4.number(),
   /** the minimum number of emitted imports from a declaration file or bundle */
-  importExpressionThreshold: z.number()
+  importExpressionThreshold: z4.number()
 });
 var isFile = async (path) => {
   return stat(path).then((stats) => stats.isFile()).catch((_) => false);
@@ -545,40 +1467,40 @@ var throwIfNotDirectory = async (path) => {
   }
   return path;
 };
-var analyzeTraceResult = z.object({
+var analyzeTraceResult = z4.object({
   /** Events that were not closed */
-  unterminatedEvents: z.array(traceEvent),
+  unterminatedEvents: z4.array(traceEvent),
   /** Hot spots in the trace */
-  hotSpots: z.array(hotSpot),
+  hotSpots: z4.array(hotSpot),
   /** Packages that are duplicated in the trace */
-  duplicatePackages: z.array(duplicatedPackage),
+  duplicatePackages: z4.array(duplicatedPackage),
   /** Paths to all node modules used in the trace */
   nodeModulePaths,
   /** Depth limit events grouped by their event name */
-  depthLimits: z.object({
-    checkCrossProductUnion_DepthLimit: z.array(
-      event_checktypes__checkCrossProductUnion_DepthLimit2
+  depthLimits: z4.object({
+    checkCrossProductUnion_DepthLimit: z4.array(
+      event_checktypes__checkCrossProductUnion_DepthLimit
     ),
-    checkTypeRelatedTo_DepthLimit: z.array(
-      event_checktypes__checkTypeRelatedTo_DepthLimit2
+    checkTypeRelatedTo_DepthLimit: z4.array(
+      event_checktypes__checkTypeRelatedTo_DepthLimit
     ),
-    getTypeAtFlowNode_DepthLimit: z.array(
-      event_checktypes__getTypeAtFlowNode_DepthLimit2
+    getTypeAtFlowNode_DepthLimit: z4.array(
+      event_checktypes__getTypeAtFlowNode_DepthLimit
     ),
-    instantiateType_DepthLimit: z.array(
-      event_checktypes__instantiateType_DepthLimit2
+    instantiateType_DepthLimit: z4.array(
+      event_checktypes__instantiateType_DepthLimit
     ),
-    recursiveTypeRelatedTo_DepthLimit: z.array(
-      event_checktypes__recursiveTypeRelatedTo_DepthLimit2
+    recursiveTypeRelatedTo_DepthLimit: z4.array(
+      event_checktypes__recursiveTypeRelatedTo_DepthLimit
     ),
-    removeSubtypes_DepthLimit: z.array(
-      event_checktypes__removeSubtypes_DepthLimit2
+    removeSubtypes_DepthLimit: z4.array(
+      event_checktypes__removeSubtypes_DepthLimit
     ),
-    traceUnionsOrIntersectionsTooLarge_DepthLimit: z.array(
-      event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit2
+    traceUnionsOrIntersectionsTooLarge_DepthLimit: z4.array(
+      event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit
     ),
-    typeRelatedToDiscriminatedType_DepthLimit: z.array(
-      event_checktypes__typeRelatedToDiscriminatedType_DepthLimit2
+    typeRelatedToDiscriminatedType_DepthLimit: z4.array(
+      event_checktypes__typeRelatedToDiscriminatedType_DepthLimit
     )
   })
 });
@@ -643,7 +1565,7 @@ var analyzeTrace = async ({
 };
 export {
   ANALYZE_TRACE_FILENAME,
-  absolutePath,
+  absolutePath2 as absolutePath,
   analyzeTrace,
   analyzeTraceOptions,
   analyzeTraceResult,