@gql.tada/cli-utils 1.7.3 → 1.8.0

package/dist/chunks/thread-chunk2.js

@@ -1,14 +1,22 @@
 var e = require("typescript");
 
-var r = require("node:path");
+var r = require("node:v8");
 
-var a = require("@gql.tada/internal");
+var a = require("node:vm");
 
-var t = require("@0no-co/graphqlsp/api");
+var t = require("node:fs");
 
-var i = require("./index-chunk2.js");
+var i = require("node:path");
 
-var o = require("./index-chunk.js");
+var n = require("node:crypto");
+
+var o = require("@gql.tada/internal");
+
+var s = require("@0no-co/graphqlsp/api");
+
+var u = require("./index-chunk2.js");
+
+var l = require("./index-chunk.js");
 
 function _interopNamespaceDefault(e) {
   var r = Object.create(null);
@@ -29,31 +37,256 @@ function _interopNamespaceDefault(e) {
   return r;
 }
 
-var n = _interopNamespaceDefault(r);
+var c = _interopNamespaceDefault(t);
 
-function traceCallToImportSource(r, a, t) {
-  var i = t.getTypeChecker();
-  var o = r.expression;
-  var n;
-  if (e.isIdentifier(o)) {
-    n = o;
-  } else if (e.isPropertyAccessExpression(o) && e.isIdentifier(o.expression)) {
-    n = o.expression;
+var f = _interopNamespaceDefault(i);
+
+var p = _interopNamespaceDefault(n);
+
+var d = /@gql\.tada\/hash\s+([^\s*]+)/;
+
+function getHashComment(r, a) {
+  var t = e.getLeadingCommentRanges(r, a.pos) || [];
+  for (var i = t.length - 1; i >= 0; i--) {
+    var n = r.slice(t[i].pos, t[i].end);
+    var o = d.exec(n);
+    if (o) {
+      return o[1];
+    }
   }
-  if (!n) {
-    return;
+  return;
+}
+
+var m = "turbo-document-hash-v1";
+
+function createDocumentHasher(r) {
+  var a = new WeakMap;
+  var t = new Map;
+  var i = new WeakSet;
+  var hashCallExpression = (e, r) => {
+    var t = r || "";
+    var n = a.get(e)?.get(t);
+    if (n) {
+      return n;
+    } else if (i.has(e)) {
+      return {
+        hashable: !1
+      };
+    }
+    i.add(e);
+    var o = computeCallExpressionHash(e, r);
+    i.delete(e);
+    var s = a.get(e);
+    if (!s) {
+      s = new Map;
+      a.set(e, s);
+    }
+    s.set(t, o);
+    return o;
+  };
+  var computeCallExpressionHash = (a, t) => {
+    var i = function getStaticStringValue(r) {
+      if (!r) {
+        return;
+      }
+      r = unwrapExpression(r);
+      if (e.isStringLiteral(r) || e.isNoSubstitutionTemplateLiteral(r)) {
+        return r.text;
+      }
+      return;
+    }(a.arguments[0]);
+    if (null == i) {
+      return {
+        hashable: !1
+      };
+    }
+    var n = getFragmentHashes(a.arguments[1], t);
+    if (!n) {
+      return {
+        hashable: !1
+      };
+    }
+    var o = p.createHash("sha256");
+    addHashPart(o, m);
+    addHashPart(o, t || "");
+    addHashPart(o, r.schemaFingerprints.get(t) || "");
+    addHashPart(o, i);
+    for (var s of n) {
+      addHashPart(o, s);
+    }
+    return {
+      hashable: !0,
+      documentHash: `sha256:${o.digest("hex").slice(0, 32)}`
+    };
+  };
+  var getFragmentHashes = (r, a) => {
+    if (!r) {
+      return [];
+    }
+    r = unwrapExpression(r);
+    if (e.isArrayLiteralExpression(r)) {
+      var t = [];
+      for (var i of r.elements) {
+        if (e.isSpreadElement(i)) {
+          var n = getFragmentHashes(i.expression, a);
+          if (!n) {
+            return null;
+          }
+          t.push(...n);
+          continue;
+        }
+        var o = resolveDocumentCallExpression(i);
+        if (!o) {
+          return null;
+        }
+        var s = hashCallExpression(o, a);
+        if (!s.hashable || !s.documentHash) {
+          return null;
+        }
+        t.push(s.documentHash);
+      }
+      return t;
+    }
+    var u = resolveDeclarationInitializer(r);
+    if (u && u !== r) {
+      return getFragmentHashes(u, a);
+    }
+    return null;
+  };
+  var resolveDocumentCallExpression = r => {
+    r = unwrapExpression(r);
+    if (e.isCallExpression(r)) {
+      return r;
+    }
+    var a = getSymbol(r);
+    if (!a) {
+      return null;
+    }
+    var i = t.get(a);
+    if (void 0 !== i) {
+      return i;
+    }
+    var n = resolveSymbolCallExpression(a);
+    t.set(a, n);
+    return n;
+  };
+  var resolveDeclarationInitializer = r => {
+    var a = getSymbol(r);
+    if (!a) {
+      return null;
+    }
+    for (var t of a.declarations || []) {
+      if (e.isVariableDeclaration(t) && t.initializer) {
+        return t.initializer;
+      }
+    }
+    return null;
+  };
+  var resolveSymbolCallExpression = r => {
+    for (var a of r.declarations || []) {
+      if (e.isVariableDeclaration(a) && a.initializer) {
+        var t = unwrapExpression(a.initializer);
+        if (e.isCallExpression(t)) {
+          return t;
+        }
+      }
+    }
+    return null;
+  };
+  var getSymbol = a => {
+    var t = r.checker.getSymbolAtLocation(a);
+    if (t && t.flags & e.SymbolFlags.Alias) {
+      t = r.checker.getAliasedSymbol(t);
+    }
+    return t;
+  };
+  return {
+    hashCallExpression
+  };
+}
+
+function unwrapExpression(r) {
+  while (e.isParenthesizedExpression(r) || e.isAsExpression(r) || e.isTypeAssertionExpression(r) || e.isSatisfiesExpression(r) || e.isNonNullExpression(r)) {
+    r = r.expression;
+  }
+  return r;
+}
+
+function addHashPart(e, r) {
+  e.update(`${r.length}:`);
+  e.update(r);
+  e.update("\0");
+}
+
+var v = /(?:^|[^\w])(query|mutation|subscription|fragment)\b/;
+
+function hasGraphQLDocumentCandidate(r) {
+  if (!r.text.includes("{")) {
+    return !1;
+  }
+  var a = !1;
+  var visit = r => {
+    if (a) {
+      return;
+    }
+    if (e.isCallExpression(r)) {
+      var t = r.arguments[0];
+      if (t && e.isStringLiteralLike(t)) {
+        var i = t.text;
+        if (i.includes("{") && function isGraphQLDocumentCandidateText(e) {
+          if (v.test(e)) {
+            return !0;
+          }
+          for (var r of e.split("\n")) {
+            var a = r.trimStart();
+            if (!a || a.startsWith("#")) {
+              continue;
+            }
+            return a.startsWith("{");
+          }
+          return !1;
+        }(i)) {
+          a = !0;
+          return;
+        }
+      }
+    }
+    e.forEachChild(r, visit);
+  };
+  visit(r);
+  return a;
+}
+
+var h = 262144e4;
+
+function traceCallToImportSource(r, a, t, i) {
+  var n = r.expression;
+  var o;
+  if (e.isIdentifier(n)) {
+    o = n;
+  } else if (e.isPropertyAccessExpression(n) && e.isIdentifier(n.expression)) {
+    o = n.expression;
   }
-  var s = i.getSymbolAtLocation(n);
-  if (!s || !s.declarations) {
+  if (!o) {
     return;
   }
-  for (var l of s.declarations) {
-    var u = findImportDeclaration(l);
-    if (u && e.isStringLiteral(u.moduleSpecifier)) {
-      return resolveModulePath(u.moduleSpecifier.text, a, t);
+  var s = `${a.fileName}\0${o.text}`;
+  if (i.traces.has(s)) {
+    return i.traces.get(s);
+  }
+  var u;
+  var l = t.getTypeChecker().getSymbolAtLocation(o);
+  if (l && l.declarations) {
+    for (var c of l.declarations) {
+      var f = findImportDeclaration(c);
+      if (f && e.isStringLiteral(f.moduleSpecifier)) {
+        u = resolveModulePath(f.moduleSpecifier.text, a, t, i);
+        break;
+      }
     }
   }
-  return;
+  i.traces.set(s, u);
+  return u;
 }
 
 function findImportDeclaration(r) {
@@ -67,167 +300,344 @@ function findImportDeclaration(r) {
   return;
 }
 
-function resolveModulePath(r, a, t) {
-  var i = t.getCompilerOptions();
-  var o = e.createCompilerHost(i);
-  var n = e.resolveModuleName(r, a.fileName, i, o);
-  if (n.resolvedModule) {
-    return n.resolvedModule.resolvedFileName;
+function resolveModulePath(r, a, t, i) {
+  var n = t.getCompilerOptions();
+  var o = i.host || (i.host = e.createCompilerHost(n));
+  var s = i.resolutionCache || (i.resolutionCache = e.createModuleResolutionCache(o.getCurrentDirectory(), o.getCanonicalFileName.bind(o), n));
+  var u = e.resolveModuleName(r, a.fileName, n, o, s);
+  if (u.resolvedModule) {
+    return u.resolvedModule.resolvedFileName;
   }
   return;
 }
 
-function collectImportsFromSourceFile(r, a, t, i, o) {
-  var s = [];
-  var l = function getTadaOutputPaths(e) {
-    var r = [];
+function collectImportsFromSourceFile(r, a, t, i, n, o, s) {
+  var u = [];
+  var l = function getTadaOutputPaths(e, r) {
+    var a = [];
     if ("schema" in e && e.tadaOutputLocation) {
-      r.push(e.tadaOutputLocation);
-    }
-    return r;
-  }(a);
-  !function visit(a) {
-    if (e.isImportDeclaration(a) && e.isStringLiteral(a.moduleSpecifier)) {
-      var u = a.moduleSpecifier.text;
-      if (!function isTadaImport(e, r, a) {
-        if (e.startsWith(".")) {
-          var t = n.dirname(r);
-          var i = n.resolve(t, e);
-          return a.some((e => {
-            var r = n.resolve(e);
-            return i === r || i.startsWith(r + n.sep);
-          }));
+      a.push(f.resolve(r, e.tadaOutputLocation));
+    } else if ("schemas" in e) {
+      for (var t of e.schemas) {
+        if (t.tadaOutputLocation) {
+          a.push(f.resolve(r, t.tadaOutputLocation));
         }
-        return a.some((r => e === r || e.startsWith(r + "/")));
-      }(u, r.fileName, l)) {
-        var c = a.getFullText().trim();
-        if (i) {
-          var p = t(u, r.fileName, i);
-          if (o) {
-            if (p.endsWith(".ts") || p.endsWith(".tsx")) {
-              p = p.replace(/\.ts$/, ".js").replace(/\.tsx$/, ".js");
+      }
+    }
+    return a;
+  }(a, n);
+  for (var c of r.statements) {
+    if (e.isImportDeclaration(c) && e.isStringLiteral(c.moduleSpecifier)) {
+      var p = c.moduleSpecifier.text;
+      if (!isTadaImport(p, r.fileName, l, i)) {
+        var d = c.getFullText().trim();
+        if (o) {
+          var m = t(p, r.fileName, o);
+          if (s) {
+            if (m.endsWith(".ts") || m.endsWith(".tsx")) {
+              m = m.replace(/\.ts$/, ".js").replace(/\.tsx$/, ".js");
             }
           } else {
-            p = p.replace(/\.ts$/, "").replace(/\.tsx$/, "");
+            m = m.replace(/\.ts$/, "").replace(/\.tsx$/, "");
           }
-          if (p && !p.includes("gql.tada")) {
-            s.push({
-              specifier: p,
-              importClause: c.replace(u, p)
+          if (m && !m.includes("gql.tada")) {
+            u.push({
+              specifier: m,
+              importClause: d.replace(p, m)
             });
           }
         } else {
-          s.push({
-            specifier: u,
-            importClause: c
+          u.push({
+            specifier: p,
+            importClause: d
           });
         }
       }
     }
-    e.forEachChild(a, visit);
-  }(r);
-  return s;
+  }
+  return u;
 }
 
-var s = i.expose((async function* _runTurbo(r) {
-  var i = a.getSchemaNamesFromConfig(r.pluginConfig);
-  var n = o.programFactory(r);
-  n.addSourceFile({
+function isTadaImport(e, r, a, t) {
+  var i = t(e, r);
+  if (i) {
+    return a.some((e => i === e));
+  }
+  if (e.startsWith(".")) {
+    var n = f.dirname(r);
+    var o = f.resolve(n, e);
+    return a.some((e => o === e));
+  }
+  return a.some((r => e === r || e.startsWith(r + "/")));
+}
+
+async function* _runTurbo(r) {
+  var a = o.getSchemaNamesFromConfig(r.pluginConfig);
+  var t = l.programFactory(r);
+  var i = new Map;
+  var getCachedDocuments = a => {
+    var t = getTurboOutputPath(r.turboOutputPath, a);
+    if (!t) {
+      return new Map;
+    }
+    var n = i.get(t);
+    if (!n) {
+      n = function readCachedTurboDocuments(r) {
+        var a = new Map;
+        if (!r || !c.existsSync(r)) {
+          return a;
+        }
+        var t;
+        try {
+          t = c.readFileSync(r, "utf8");
+        } catch {
+          return a;
+        }
+        var i = e.createSourceFile(r, t, e.ScriptTarget.Latest, !0, e.ScriptKind.TS);
+        var visit = r => {
+          if (e.isInterfaceDeclaration(r) && "setupCache" === r.name.text) {
+            for (var n of r.members) {
+              if (!e.isPropertySignature(n) || !n.type) {
+                continue;
+              }
+              if (!e.isStringLiteral(n.name) && !e.isNumericLiteral(n.name)) {
+                continue;
+              }
+              var o = getHashComment(t, n);
+              if (!o) {
+                continue;
+              }
+              a.set(JSON.stringify(n.name.text), {
+                documentHash: o,
+                documentType: n.type.getText(i)
+              });
+            }
+          }
+          e.forEachChild(r, visit);
+        };
+        visit(i);
+        return a;
+      }(t);
+      i.set(t, n);
+    }
+    return n;
+  };
+  t.addSourceFile({
     fileId: "__gql-tada-override__.d.ts",
-    sourceText: u,
+    sourceText: T,
     scriptKind: e.ScriptKind.TS
   });
-  var s = n.createExternalFiles();
-  if (s.length) {
+  var n = t.createExternalFiles();
+  if (n.length) {
     yield {
       kind: "EXTERNAL_WARNING"
     };
-    await n.addVirtualFiles(s);
+    await t.addVirtualFiles(n);
   }
-  var c = n.build();
-  var p = c.buildPluginInfo(r.pluginConfig);
-  var f = c.getSourceFiles();
+  var u = t.build();
+  var p = u.buildPluginInfo(r.pluginConfig);
+  var d = new Set(function getTurboOutputPaths(e) {
+    return "string" == typeof e ? [ e ] : e.map((e => e.path));
+  }(r.turboOutputPath).map((e => f.resolve(e))));
+  var m = t.rootFileNames.filter((e => function shouldScanTurboFile(e, r) {
+    if (r.has(f.resolve(e))) {
+      return !1;
+    }
+    if (e.endsWith(".d.ts") || e.endsWith(".d.mts") || e.endsWith(".d.cts")) {
+      return !1;
+    }
+    return !/(^|[/\\])node_modules([/\\]|$)/.test(e);
+  }(e, d)));
   yield {
     kind: "FILE_COUNT",
-    fileCount: f.length
+    fileCount: m.length
   };
-  var d = c.program.getTypeChecker();
-  var m = new Map;
-  for (var v of f) {
-    var g = v.fileName;
-    var h = [];
-    var y = [];
-    var T = t.findAllCallExpressions(v, p, !1).nodes;
-    var _loop = async function*(a) {
-      var t = a.node.parent;
-      if (!e.isCallExpression(t)) {
-        return 0;
+  var v = new Map;
+  var g = {
+    traces: new Map,
+    host: void 0,
+    resolutionCache: void 0
+  };
+  var processSourceFile = (i, n, o, u) => {
+    var l = i.fileName;
+    var c = [];
+    var f = [];
+    if (!hasGraphQLDocumentCandidate(i)) {
+      return {
+        filePath: l,
+        documents: c,
+        warnings: f
+      };
+    }
+    var p = s.findAllCallExpressions(i, o, {
+      searchExternal: !1,
+      collectFragments: !1
+    }).nodes;
+    for (var d of p) {
+      var m = d.node.parent;
+      if (!e.isCallExpression(m)) {
+        continue;
       }
-      var o = c.getSourcePosition(v, t.getStart());
-      g = o.fileName;
-      if (!i.has(a.schema)) {
-        y.push({
-          message: a.schema ? `The '${a.schema}' schema is not in the configuration but was referenced by document.` : i.size > 1 ? "The document is not for a known schema. Have you re-generated the output file?" : "Multiple schemas are configured, but the document is not for a specific schema.",
-          file: o.fileName,
-          line: o.line,
-          col: o.col
+      var h = n.getSourcePosition(i, m.getStart());
+      l = h.fileName;
+      if (!a.has(d.schema)) {
+        f.push({
+          message: d.schema ? `The '${d.schema}' schema is not in the configuration but was referenced by document.` : a.size > 1 ? "The document is not for a known schema. Have you re-generated the output file?" : "Multiple schemas are configured, but the document is not for a specific schema.",
+          file: h.fileName,
+          line: h.line,
+          col: h.col
         });
-        return 0;
+        continue;
       }
-      var s = traceCallToImportSource(t, v, c.program);
-      if (s && !m.has(s)) {
-        var u = c.program.getSourceFile(s);
-        if (u) {
-          var p = Array.isArray(r.turboOutputPath) ? r.turboOutputPath.find((e => e.schemaName === a.schema))?.path : r.turboOutputPath;
-          var f = collectImportsFromSourceFile(u, r.pluginConfig, n.resolveModuleName.bind(n), p, !!n.wasOriginallyNodeNext);
-          m.set(s, {
-            absolutePath: s,
-            imports: f
+      var y = traceCallToImportSource(m, i, n.program, g);
+      if (y && !v.has(y)) {
+        var T = n.program.getSourceFile(y);
+        if (T) {
+          var F = getTurboOutputPath(r.turboOutputPath, d.schema);
+          var b = collectImportsFromSourceFile(T, r.pluginConfig, t.resolveModuleName.bind(t), t.resolveModulePath.bind(t), r.rootPath, F, !!t.wasOriginallyNodeNext);
+          v.set(y, {
+            absolutePath: y,
+            imports: b
           });
         }
       }
-      var T = d.getTypeAtLocation(t);
-      var F = d.getTypeAtLocation(a.node);
-      if (!T.symbol || "TadaDocumentNode" !== T.symbol.getEscapedName()) {
-        y.push({
-          message: 'The discovered document is not of type "TadaDocumentNode".\nIf this is unexpected, please file an issue describing your case.',
-          file: o.fileName,
-          line: o.line,
-          col: o.col
-        });
-        return 0;
+      var C = JSON.stringify(d.node.text);
+      var N = x.hashCallExpression(m, d.schema);
+      var P = N.hashable && N.documentHash ? getCachedDocuments(d.schema).get(C) : void 0;
+      var E = void 0;
+      var w = !1;
+      if (P && P.documentHash === N.documentHash) {
+        E = P.documentType;
+        w = !0;
+      } else {
+        var O = u.getTypeAtLocation(m);
+        if (!O.symbol || "TadaDocumentNode" !== O.symbol.getEscapedName()) {
+          f.push({
+            message: 'The discovered document is not of type "TadaDocumentNode".\nIf this is unexpected, please file an issue describing your case.',
+            file: h.fileName,
+            line: h.line,
+            col: h.col
+          });
+          continue;
+        }
+        E = u.typeToString(O, m, S);
       }
-      var S = "value" in F && "string" == typeof F.value && !(F.flags & e.TypeFlags.StringLiteral) ? JSON.stringify(F.value) : d.typeToString(F, t, l);
-      var N = d.typeToString(T, t, l);
-      h.push({
-        schemaName: a.schema,
-        argumentKey: S,
-        documentType: N
+      c.push({
+        schemaName: d.schema,
+        argumentKey: C,
+        documentType: E,
+        documentHash: N.documentHash,
+        isCached: w
       });
+    }
+    return {
+      filePath: l,
+      documents: c,
+      warnings: f
     };
-    for (var F of T) {
-      if (0 === (yield* _loop(F))) {
-        continue;
-      }
+  };
+  var isHeapOverSoftLimit = () => {
+    if (process.memoryUsage().heapUsed < h) {
+      return !1;
     }
+    forceGc();
+    return process.memoryUsage().heapUsed >= h;
+  };
+  var y = u.program.getTypeChecker();
+  var x = createDocumentHasher({
+    get checker() {
+      return y;
+    },
+    schemaFingerprints: computeSchemaFingerprints(r)
+  });
+  var F = 0;
+  for (var b of m) {
+    if (F > 0 && (F >= 1e3 || isHeapOverSoftLimit())) {
+      p = (u = t.build()).buildPluginInfo(r.pluginConfig);
+      forceGc();
+      y = u.program.getTypeChecker();
+      F = 0;
+    }
+    var C = u.getSourceFile(b);
+    if (!C) {
+      continue;
+    }
+    var {filePath: N, documents: P, warnings: E} = processSourceFile(C, u, p, y);
+    F++;
     yield {
       kind: "FILE_TURBO",
-      filePath: g,
-      documents: h,
-      warnings: y
+      filePath: N,
+      documents: P,
+      warnings: E
     };
   }
-  if (m.size > 0) {
+  if (v.size > 0) {
     yield {
       kind: "GRAPHQL_SOURCES",
-      sources: Array.from(m.values())
+      sources: Array.from(v.values())
     };
   }
-}));
+}
+
+function computeSchemaFingerprints(e) {
+  var r = new Map;
+  var a = f.dirname(e.configPath);
+  for (var t of o.getSchemaNamesFromConfig(e.pluginConfig)) {
+    var i = o.getSchemaConfigForName(e.pluginConfig, t || void 0);
+    var n = i && i.tadaOutputLocation;
+    if (!n) {
+      continue;
+    }
+    var s = void 0;
+    try {
+      s = c.readFileSync(f.resolve(a, n), "utf8");
+    } catch {
+      continue;
+    }
+    var u = p.createHash("sha256").update(s).digest("hex");
+    r.set(t, `sha256:${u.slice(0, 32)}`);
+  }
+  return r;
+}
+
+function getTurboOutputPath(e, r) {
+  if ("string" == typeof e) {
+    return e;
+  }
+  return e.find((e => e.schemaName === r))?.path;
+}
+
+var g;
+
+function forceGc() {
+  if (void 0 === g) {
+    var e = globalThis.gc;
+    if ("function" == typeof e) {
+      g = e;
+    } else {
+      try {
+        r.setFlagsFromString("--expose-gc");
+        g = a.runInNewContext("gc");
+        r.setFlagsFromString("--no-expose-gc");
+      } catch {
+        g = null;
+      }
+    }
+  }
+  if (g) {
+    g();
+  }
+}
+
+var y = u.expose(_runTurbo);
+
+var S = e.TypeFormatFlags.NoTruncation | e.TypeFormatFlags.NoTypeReduction | e.TypeFormatFlags.InTypeAlias | e.TypeFormatFlags.UseFullyQualifiedType | e.TypeFormatFlags.GenerateNamesForShadowedTypeParams | e.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | e.TypeFormatFlags.AllowUniqueESSymbolType | e.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+
+var T = "\nimport * as _gqlTada from 'gql.tada';\ndeclare module 'gql.tada' {\n  interface setupCache {\n    readonly __cacheDisabled: true;\n  }\n}\n".trim();
 
-var l = e.TypeFormatFlags.NoTruncation | e.TypeFormatFlags.NoTypeReduction | e.TypeFormatFlags.InTypeAlias | e.TypeFormatFlags.UseFullyQualifiedType | e.TypeFormatFlags.GenerateNamesForShadowedTypeParams | e.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | e.TypeFormatFlags.AllowUniqueESSymbolType | e.TypeFormatFlags.WriteTypeArgumentsOfSignature;
+exports._runTurbo = _runTurbo;
 
-var u = "\nimport * as _gqlTada from 'gql.tada';\ndeclare module 'gql.tada' {\n  interface setupCache {\n    readonly __cacheDisabled: true;\n  }\n}\n".trim();
+exports.collectImportsFromSourceFile = collectImportsFromSourceFile;
 
-exports.runTurbo = s;
+exports.runTurbo = y;
 //# sourceMappingURL=thread-chunk2.js.map