@typeslayer/validate 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1023 @@
+// src/package-name.ts
+var packageNameRegex = /\/node_modules\/((?:[^@][^/]+)|(?:@[^/]+\/[^/]+))/g;
+var extractPackageName = (path) => {
+  const pnpmSentinel = "/node_modules/.pnpm/";
+  if (path.includes(pnpmSentinel)) {
+    const startIndex = path.indexOf(pnpmSentinel) + pnpmSentinel.length;
+    const endIndex = path.indexOf("/", startIndex);
+    if (endIndex === -1) {
+      throw new Error(
+        "Invalid path format: no closing slash found after pnpm sentinel"
+      );
+    }
+    return path.substring(startIndex, endIndex).replace("+", "/");
+  }
+  return path;
+};
+function relativizePath(from, to) {
+  const fromURL = new URL(`file://${from.endsWith("/") ? from : `${from}/}`}`);
+  const toURL = new URL(`file://${to}`);
+  const fromParts = fromURL.pathname.split("/").filter(Boolean);
+  const toParts = toURL.pathname.split("/").filter(Boolean);
+  let i = 0;
+  while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
+    i++;
+  }
+  const up = fromParts.length - i;
+  const down = toParts.slice(i).join("/");
+  return `${"../".repeat(up)}${down}`;
+}
+
+// src/trace-json.ts
+import { z as z2 } from "zod/v4";
+
+// src/utils.ts
+import { z } from "zod/v4";
+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
+});
+
+// src/trace-json.ts
+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().positive(),
+    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);
+
+// src/tsc-cpuprofile.ts
+var CPU_PROFILE_FILENAME = "tsc.cpuprofile";
+
+// src/type-registry.ts
+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
+  );
+};
+
+// src/types-json.ts
+import { z as z3 } from "zod/v4";
+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);
+export {
+  CPU_PROFILE_FILENAME,
+  TRACE_JSON_FILENAME,
+  TYPES_JSON_FILENAME,
+  createTypeRegistry,
+  depthLimits,
+  eventPhase,
+  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,
+  extractPackageName,
+  packageNameRegex,
+  relativizePath,
+  resolvedType,
+  traceEvent,
+  traceJsonSchema,
+  typesJsonSchema
+};
+//# sourceMappingURL=index.js.map