@code0-tech/triangulum 0.1.0 → 0.3.0

package/dist/triangulum.es.js

@@ -1,5 +1,215 @@
-import t from "typescript";
-const w = `
+import y, { flattenDiagnosticMessageText as Z } from "typescript";
+function A() {
+  return A = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var r in n) ({}).hasOwnProperty.call(n, r) && (e[r] = n[r]);
+    }
+    return e;
+  }, A.apply(null, arguments);
+}
+var W = !1;
+try {
+  W = typeof localStorage < "u";
+} catch {
+}
+var X = typeof process < "u", ee = W && typeof localStorage.getItem == "function" && /* @__PURE__ */ localStorage.getItem("DEBUG") || X && process.env.DEBUG, J = ee ? console.log : function(e) {
+  return "";
+};
+function te(e, t, n, r, o) {
+  r === void 0 && (r = {});
+  var s = A({}, G(n), r), c = re(e, t, s, n, o), a = c.languageServiceHost, u = c.updateFile, p = c.deleteFile, l = n.createLanguageService(a), h = l.getCompilerOptionsDiagnostics();
+  if (h.length) {
+    var i = Y(e, r, n);
+    throw new Error(n.formatDiagnostics(h, i.compilerHost));
+  }
+  return {
+    // @ts-ignore
+    name: "vfs",
+    sys: e,
+    languageService: l,
+    getSourceFile: function(v) {
+      var d;
+      return (d = l.getProgram()) == null ? void 0 : d.getSourceFile(v);
+    },
+    createFile: function(v, d) {
+      u(n.createSourceFile(v, d, s.target, !1));
+    },
+    updateFile: function(v, d, T) {
+      var g = l.getProgram().getSourceFile(v);
+      if (!g)
+        throw new Error("Did not find a source file for " + v);
+      var S = g.text, m = T ?? n.createTextSpan(0, S.length), $ = S.slice(0, m.start) + d + S.slice(m.start + m.length), F = n.updateSourceFile(g, $, {
+        span: m,
+        newLength: d.length
+      });
+      u(F);
+    },
+    deleteFile: function(v) {
+      var d = l.getProgram().getSourceFile(v);
+      d && p(d);
+    }
+  };
+}
+function R(e) {
+  throw new Error("Method '" + e + "' is not implemented.");
+}
+function w(e, t) {
+  return function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    var s = t.apply(void 0, r), c = typeof s == "string" ? s.slice(0, 80) + "..." : s;
+    return J.apply(void 0, ["> " + e].concat(r)), J("< " + c), s;
+  };
+}
+var G = function(t) {
+  return A({}, t.getDefaultCompilerOptions(), {
+    jsx: t.JsxEmit.React,
+    strict: !0,
+    esModuleInterop: !0,
+    module: t.ModuleKind.ESNext,
+    suppressOutputPathCheck: !0,
+    skipLibCheck: !0,
+    skipDefaultLibCheck: !0
+  }, t.versionMajorMinor && Number(t.versionMajorMinor.split(".")[0]) >= 6 ? {
+    ignoreDeprecations: "6.0"
+  } : {
+    moduleResolution: t.ModuleResolutionKind.NodeJs
+  });
+}, K = function(t) {
+  return t.replace("/", "/lib.").toLowerCase();
+};
+function ne(e) {
+  return {
+    args: [],
+    createDirectory: function() {
+      return R("createDirectory");
+    },
+    // TODO: could make a real file tree
+    directoryExists: w("directoryExists", function(t) {
+      return Array.from(e.keys()).some(function(n) {
+        return n.startsWith(t);
+      });
+    }),
+    exit: function() {
+      return R("exit");
+    },
+    fileExists: w("fileExists", function(t) {
+      return e.has(t) || e.has(K(t));
+    }),
+    getCurrentDirectory: function() {
+      return "/";
+    },
+    getDirectories: function() {
+      return [];
+    },
+    getExecutingFilePath: function() {
+      return R("getExecutingFilePath");
+    },
+    readDirectory: w("readDirectory", function(t) {
+      return t === "/" ? Array.from(e.keys()) : [];
+    }),
+    readFile: w("readFile", function(t) {
+      var n;
+      return (n = e.get(t)) != null ? n : e.get(K(t));
+    }),
+    resolvePath: function(n) {
+      return n;
+    },
+    newLine: `
+`,
+    useCaseSensitiveFileNames: !0,
+    write: function() {
+      return R("write");
+    },
+    writeFile: function(n, r) {
+      e.set(n, r);
+    },
+    deleteFile: function(n) {
+      e.delete(n);
+    }
+  };
+}
+function Y(e, t, n) {
+  var r = /* @__PURE__ */ new Map(), o = function(a) {
+    return r.set(a.fileName, a), a;
+  }, s = {
+    compilerHost: A({}, e, {
+      getCanonicalFileName: function(a) {
+        return a;
+      },
+      getDefaultLibFileName: function() {
+        return "/" + n.getDefaultLibFileName(t);
+      },
+      // '/lib.d.ts',
+      // getDefaultLibLocation: () => '/',
+      getNewLine: function() {
+        return e.newLine;
+      },
+      getSourceFile: function(a, u) {
+        var p;
+        return r.get(a) || o(n.createSourceFile(a, e.readFile(a), (p = u ?? t.target) != null ? p : G(n).target, !1));
+      },
+      useCaseSensitiveFileNames: function() {
+        return e.useCaseSensitiveFileNames;
+      }
+    }),
+    updateFile: function(a) {
+      var u = r.has(a.fileName);
+      return e.writeFile(a.fileName, a.text), r.set(a.fileName, a), u;
+    },
+    deleteFile: function(a) {
+      var u = r.has(a.fileName);
+      return r.delete(a.fileName), e.deleteFile(a.fileName), u;
+    }
+  };
+  return s;
+}
+function re(e, t, n, r, o) {
+  var s = [].concat(t), c = Y(e, n, r), a = c.compilerHost, u = c.updateFile, p = c.deleteFile, l = /* @__PURE__ */ new Map(), h = 0, i = A({}, a, {
+    getProjectVersion: function() {
+      return h.toString();
+    },
+    getCompilationSettings: function() {
+      return n;
+    },
+    getCustomTransformers: function() {
+      return o;
+    },
+    // A couple weeks of 4.8 TypeScript nightlies had a bug where the Program's
+    // list of files was just a reference to the array returned by this host method,
+    // which means mutations by the host that ought to result in a new Program being
+    // created were not detected, since the old list of files and the new list of files
+    // were in fact a reference to the same underlying array. That was fixed in
+    // https://github.com/microsoft/TypeScript/pull/49813, but since the twoslash runner
+    // is used in bisecting for changes, it needs to guard against being busted in that
+    // couple-week period, so we defensively make a slice here.
+    getScriptFileNames: function() {
+      return s.slice();
+    },
+    getScriptSnapshot: function(d) {
+      var T = e.readFile(d);
+      if (T && typeof T == "string")
+        return r.ScriptSnapshot.fromString(T);
+    },
+    getScriptVersion: function(d) {
+      return l.get(d) || "0";
+    },
+    writeFile: e.writeFile
+  }), f = {
+    languageServiceHost: i,
+    updateFile: function(d) {
+      h++, l.set(d.fileName, h.toString()), s.includes(d.fileName) || s.push(d.fileName), u(d);
+    },
+    deleteFile: function(d) {
+      h++, l.set(d.fileName, h.toString());
+      var T = s.indexOf(d.fileName);
+      T !== -1 && s.splice(T, 1), p(d);
+    }
+  };
+  return f;
+}
+const ie = `
     interface Array<T> { 
         [n: number]: T; 
         length: number; 
@@ -15,570 +225,571 @@ const w = `
     interface RegExp { }
     type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
 `;
-function I(n, s, r) {
-  return {
-    getSourceFile: (e) => {
-      if (e === n) return r;
-      if (e.includes("lib.") || e.endsWith(".d.ts")) return t.createSourceFile(e, w, t.ScriptTarget.Latest);
-    },
-    writeFile: () => {
-    },
-    getDefaultLibFileName: () => "lib.d.ts",
-    useCaseSensitiveFileNames: () => !0,
-    getCanonicalFileName: (e) => e,
-    getCurrentDirectory: () => "/",
-    getNewLine: () => `
-`,
-    fileExists: (e) => e === n || e.includes("lib.") || e.endsWith(".d.ts"),
-    readFile: (e) => e === n ? s : e.includes("lib.") || e.endsWith(".d.ts") ? w : void 0,
-    directoryExists: () => !0,
-    getDirectories: () => []
-  };
+function I(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  n.set(e, t), n.set("lib.codezero.d.ts", ie);
+  const r = ne(n);
+  return te(r, [e, "lib.codezero.d.ts"], y, oe);
 }
-const x = {
-  target: t.ScriptTarget.Latest,
-  lib: ["lib.esnext.d.ts"],
+const oe = {
+  target: y.ScriptTarget.Latest,
+  lib: ["lib.codezero.d.ts"],
   noEmit: !0,
   strictNullChecks: !0
 };
-function E(n) {
-  const s = Array.from(new Set(n.flatMap((e) => e.genericKeys || []))).map((e) => `type ${e} = any;`).join(`
-`), r = n.map(
-    (e) => `type ${e.identifier}${e.genericKeys ? `<${e.genericKeys.join(",")}>` : ""} = ${e.type};`
+function V(e) {
+  const t = Array.from(new Set(e?.flatMap((r) => r.genericKeys || []))).map((r) => `type ${r} = any;`).join(`
+`), n = e?.map(
+    (r) => `type ${r.identifier}${r.genericKeys ? `<${r.genericKeys.join(",")}>` : ""} = ${r.type};`
   ).join(`
 `);
-  return `${s}
-${r}`;
+  return `${t}
+${n}`;
 }
-function Y(n, s) {
-  let r = n;
-  for (const e of s) {
-    if (r == null) return "unknown";
-    typeof e.path == "string" && (r = r[e.path]);
+function ae(e, t) {
+  let n = e;
+  for (const r of t) {
+    if (n == null) return "unknown";
+    typeof r.path == "string" && (n = n[r.path]);
   }
-  return typeof r;
+  return typeof n;
 }
-function j(n, s) {
-  const r = n.nodes;
-  if (r)
-    return Array.isArray(r) ? r.find((e) => e.id === s) : r.nodes?.find((e) => e.id === s);
+function B(e, t) {
+  const n = e?.nodes;
+  if (n)
+    return Array.isArray(n) ? n.find((r) => r.id === t) : n.nodes?.find((r) => r.id === t);
 }
-function K(n, s, r) {
-  const e = n?.value;
-  if (!e) return "undefined";
-  if (e.__typename === "ReferenceValue") {
-    const o = e, c = j(s, o.nodeFunctionId);
-    if (!c) return "undefined";
-    let u = r(s, c).inferredType;
+function q(e, t, n) {
+  const r = e?.value;
+  if (!r) return "undefined";
+  if (r.__typename === "ReferenceValue") {
+    const o = r, s = B(t, o.nodeFunctionId);
+    if (!s) return "undefined";
+    let c = n?.(t, s).returnType;
     if (o.referencePath && o.referencePath.length > 0) {
-      let d;
-      const y = c.parameters?.nodes;
-      if (y && y.length > 0) {
-        const p = y[0];
-        p?.value?.__typename === "LiteralValue" && (d = p.value.value);
+      let a;
+      const u = s.parameters?.nodes;
+      if (u && u.length > 0) {
+        const p = u[0];
+        p?.value?.__typename === "LiteralValue" && (a = p.value.value);
       }
-      u = Y(d, o.referencePath);
+      c = ae(a, o.referencePath);
     }
-    return `({} as ${u})`;
+    return `({} as ${c})`;
   }
-  if (e.__typename === "NodeFunctionIdWrapper") {
-    const o = e.id, c = j(s, o);
-    if (!c) return "(() => undefined)";
-    const u = (p) => {
+  if (r.__typename === "NodeFunctionIdWrapper") {
+    const o = r.id, s = B(t, o);
+    if (!s) return "(() => undefined)";
+    const c = (p) => {
       if (p.functionDefinition?.identifier === "std::control::return")
         return p;
-      const m = p.nextNodeId ? j(s, p.nextNodeId) : void 0;
-      return m ? u(m) : void 0;
-    }, d = u(c);
-    return d ? `(() => ({} as ${r(s, d).inferredType}))` : "(() => undefined)";
+      const l = p.nextNodeId ? B(t, p.nextNodeId) : void 0;
+      return l ? c(l) : void 0;
+    }, a = c(s);
+    return a ? `(() => ({} as ${n?.(t, a)?.returnType}))` : "(() => undefined)";
   }
-  return e.__typename === "LiteralValue" ? JSON.stringify(e.value) : "undefined";
+  return r.__typename === "LiteralValue" ? JSON.stringify(r.value) : "undefined";
 }
-const B = (n, s) => {
-  const r = n.nodes?.nodes;
-  if (r)
-    return r.find(
-      (e) => e?.parameters?.nodes?.some(
-        (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === s
+const H = (e, t) => {
+  const n = e?.nodes?.nodes;
+  if (n)
+    return n.find(
+      (r) => r?.parameters?.nodes?.some(
+        (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === t
       )
     );
-}, J = (n, s, r, e = /* @__PURE__ */ new Set()) => {
-  const o = s.id;
-  if (!o || e.has(o)) return !1;
-  e.add(o);
-  const c = (d) => {
-    const y = n.nodes?.nodes?.find((p) => p?.nextNodeId === d);
-    return y ? y.id === r ? !0 : c(y.id) : !1;
+}, Q = (e, t, n, r = /* @__PURE__ */ new Set()) => {
+  const o = t?.id;
+  if (!o || r.has(o)) return !1;
+  r.add(o);
+  const s = (a) => {
+    const u = e?.nodes?.nodes?.find((p) => p?.nextNodeId === a);
+    return u ? u.id === n ? !0 : s(u.id) : !1;
   };
-  if (c(o)) return !0;
-  const u = B(n, o);
-  return u ? u.id === r ? !0 : J(n, u, r, e) : !1;
-}, z = (n, s, r) => {
-  if (!r.nodeFunctionId)
+  if (s(o)) return !0;
+  const c = H(e, o);
+  return c ? c.id === n ? !0 : Q(e, c, n, r) : !1;
+}, se = (e, t, n) => {
+  if (!n?.nodeFunctionId)
     return { isValid: !0 };
-  if (r.parameterIndex !== void 0 && r.inputIndex !== void 0) {
-    if (s.id === r.nodeFunctionId) return { isValid: !0 };
-    let e = B(n, s.id);
-    for (; e; ) {
-      if (e.id === r.nodeFunctionId) return { isValid: !0 };
-      e = B(n, e.id);
+  if (n.parameterIndex !== void 0 && n.inputIndex !== void 0) {
+    if (t?.id === n.nodeFunctionId) return { isValid: !0 };
+    let r = H(e, t?.id);
+    for (; r; ) {
+      if (r.id === n.nodeFunctionId) return { isValid: !0 };
+      r = H(e, r.id);
     }
     return {
       isValid: !1,
-      error: `Invalid input reference: Node ${s.id} is not in the scope of Node ${r.nodeFunctionId}.`
+      error: `Invalid input reference: Node ${t?.id} is not in the scope of Node ${n.nodeFunctionId}.`
     };
   }
-  return J(n, s, r.nodeFunctionId) ? { isValid: !0 } : {
+  return Q(e, t, n.nodeFunctionId) ? { isValid: !0 } : {
     isValid: !1,
-    error: `Node ${r.nodeFunctionId} has not been executed yet or is not visible in this scope.`
+    error: `Node ${n.nodeFunctionId} has not been executed yet or is not visible in this scope.`
   };
-}, M = (n) => n.replace(/[^a-zA-Z0-9]/g, "_"), Z = (n, s, r) => {
-  const e = /* @__PURE__ */ new Set(), o = n.nodes?.nodes || [], c = new Map(s.map((f) => [f.identifier, f])), u = (f, N = "") => {
-    if (e.has(f)) return "";
-    const l = o.find((R) => R?.id === f);
-    if (!l || !l.functionDefinition) return "";
-    e.add(f);
-    const v = c.get(l.functionDefinition?.identifier);
-    if (!v) return `${N}// Error: Function ${l.functionDefinition.identifier} not found
-`;
-    const S = (l.parameters?.nodes || []).map((R, D) => {
-      const P = R.value;
-      if (!P) return "undefined";
-      if (P.__typename === "ReferenceValue") {
-        const L = P;
-        if (!L.nodeFunctionId) return "undefined";
-        let b = L.parameterIndex !== void 0 ? `p_${M(L.nodeFunctionId)}_${L.parameterIndex}` : `node_${M(L.nodeFunctionId)}`;
-        return L.referencePath?.forEach((O) => {
-          b += `?.${O.path}`;
-        }), b;
-      }
-      if (P.__typename === "LiteralValue")
-        return JSON.stringify(P.value);
-      if (P.__typename === "NodeFunctionIdWrapper") {
-        const L = P, b = `p_${M(l.id)}_${D}`, O = u(L.id, N + "  ");
-        return `(${b}) => {
-${O}${N}}`;
+}, fe = (e) => {
+  const n = `const tempValue = ${JSON.stringify(e?.value) ?? "any"};`, r = "index.ts", o = I(r, n), s = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker();
+  let u = "any";
+  const p = (l) => {
+    if (y.isVariableDeclaration(l) && l.name.getText() === "tempValue") {
+      const h = a.getTypeAtLocation(l);
+      u = a.typeToString(
+        h,
+        l,
+        y.TypeFormatFlags.NoTruncation | y.TypeFormatFlags.UseFullyQualifiedType
+      );
+    }
+    y.forEachChild(l, p);
+  };
+  return p(s), u;
+};
+var ce = /* @__PURE__ */ ((e) => (e[e.PRIMITIVE = 0] = "PRIMITIVE", e[e.TYPE = 1] = "TYPE", e[e.ARRAY = 2] = "ARRAY", e[e.OBJECT = 3] = "OBJECT", e[e.NODE = 4] = "NODE", e))(ce || {});
+const de = (e, t) => {
+  const r = `
+        ${V(t)}
+        type TargetType = ${e};
+        const val: TargetType = {} as any;
+    `, o = "index.ts", s = I(o, r), c = s.getSourceFile(o), u = s.languageService.getProgram().getTypeChecker();
+  let p = 1;
+  const l = (h) => {
+    if (y.isVariableDeclaration(h) && h.name.getText() === "val") {
+      const i = u.getTypeAtLocation(h);
+      i.getCallSignatures().length > 0 ? p = 4 : u.isArrayType(i) ? p = 2 : i.isStringLiteral() || i.isNumberLiteral() || (i.getFlags() & (y.TypeFlags.String | y.TypeFlags.Number | y.TypeFlags.Boolean | y.TypeFlags.EnumLiteral | y.TypeFlags.BigInt | y.TypeFlags.ESSymbol)) !== 0 ? p = 0 : (i.isClassOrInterface() || (i.getFlags() & y.TypeFlags.Object) !== 0) && i.getProperties().length > 0 ? p = 3 : p = 1;
+    }
+    y.forEachChild(h, l);
+  };
+  return l(c), p;
+}, ge = (e, t) => {
+  const n = `
+        ${V(t)}
+        type Target = ${e};
+    `, r = "index.ts", o = I(r, n), s = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker(), u = s.statements.find(
+    (i) => y.isTypeAliasDeclaration(i) && i.name.text === "Target"
+  );
+  if (!u)
+    return { __typename: "LiteralValue", value: null };
+  const p = a.getTypeAtLocation(u.type), l = (i, f, v = /* @__PURE__ */ new Set()) => {
+    if (v.has(i)) return null;
+    v.add(i);
+    const d = i.getFlags();
+    if (i.isUnion()) {
+      if (f.type, y.isTypeAliasDeclaration(f) && f.type && y.isUnionTypeNode(f.type)) {
+        const S = a.getTypeFromTypeNode(f.type.types[0]);
+        return l(S, f, v);
       }
-      return "undefined";
-    }).join(", "), $ = `node_${M(l.id)}`, C = `fn_${v.identifier?.replace(/::/g, "_")}`, A = S.includes("undefined") || (v.genericKeys?.length ?? 0) > 0;
-    let V = `${N}const ${$} = ${C}(${S})${A ? " as any" : ""} ;
-`;
-    return l.nextNodeId && (V += u(l.nextNodeId, N)), V;
-  }, d = E(r), y = s.map((f) => `declare function fn_${f.identifier?.replace(/::/g, "_")}${f.signature}`).join(`
-`), p = o.map((f) => f?.id ? u(f.id) : "").filter((f) => f !== "").join(`
-`), m = `${d}
-${y}
-
-// --- Flow ---
-${p}`, a = "flow_virtual.ts", i = t.createSourceFile(a, m, t.ScriptTarget.Latest), g = I(a, m, i), h = t.createProgram([a], x, g).getSemanticDiagnostics(i).map((f) => {
-    const N = t.flattenDiagnosticMessageText(f.messageText, `
-`);
-    return N.includes("Argument of type 'undefined'") || N.includes("not assignable to type 'undefined'") ? null : {
-      message: N,
-      code: f.code,
-      severity: "error"
-    };
-  }).filter((f) => f !== null);
+      const T = i.types.filter((S) => {
+        const m = S.getFlags();
+        return !(m & y.TypeFlags.Undefined) && !(m & y.TypeFlags.Null);
+      }), g = T.length > 0 ? T[0] : i.types[0];
+      return l(g, f, v);
+    }
+    if (d & y.TypeFlags.StringLiteral) return i.value;
+    if (d & y.TypeFlags.String) return "sample";
+    if (d & y.TypeFlags.NumberLiteral) return i.value;
+    if (d & y.TypeFlags.Number) return 1;
+    if (d & y.TypeFlags.BooleanLiteral) return i.intrinsicName === "true";
+    if (d & y.TypeFlags.Boolean) return !1;
+    if (a.isArrayType(i)) {
+      const g = i.typeArguments?.[0] || a.getAnyType();
+      return [l(g, f, v)];
+    }
+    if (i.isClassOrInterface() || d & y.TypeFlags.Object || i.getProperties().length > 0) {
+      const T = {};
+      return i.getProperties().forEach((S) => {
+        const m = a.getTypeOfSymbolAtLocation(S, f);
+        m && (T[S.getName()] = l(m, f, v));
+      }), T;
+    }
+    return null;
+  };
   return {
-    isValid: h.length === 0,
-    inferredType: "void",
-    errors: h
+    value: l(p, u)
   };
-}, G = [
-  { identifier: "LIST", type: "T[]", genericKeys: ["T"] },
-  { identifier: "NUMBER", type: "number" },
-  { identifier: "HTTP_METHOD", type: '"GET" | "POST" | "PUT" | "DELETE"' },
-  { identifier: "STRING", type: "string" },
-  { identifier: "CONSUMER", type: "(item:R) => void", genericKeys: ["R"] },
-  { identifier: "PREDICATE", type: "(item:R) => T", genericKeys: ["R", "T"] },
-  { identifier: "NUMBER_ARRAY", type: "LIST<NUMBER>", linkedDataTypeIdentifiers: ["LIST", "NUMBER"] }
-];
-function X(n, s) {
-  if (!n || !s || s.length === 0)
-    return [];
-  const r = "suggestions.ts", e = E(G);
-  function o(a) {
-    const i = a.match(/<([^>]+)>/);
-    return i ? i[1].split(",").map((g) => g.trim()).filter(Boolean).length : 0;
-  }
-  const c = `
-        ${e}
-        type TargetType = ${n};
-        ${s.map((a, i) => `
-        declare function Fu${i}${a.signature};
-        type F${i} = ReturnType<typeof Fu${i}${o(a.signature) > 0 ? `<${Array(o(a.signature)).fill("any").join(", ")}>` : ""}>;
-        `).join(`
-`)}
-        ${s.map((a, i) => `const check${i}: TargetType = {} as F${i};`).join(`
-`)}
-    `;
-  console.log(c);
-  const u = t.createSourceFile(r, c, t.ScriptTarget.Latest), d = I(r, c, u), p = t.createProgram([r], {
-    ...x
-  }, d).getSemanticDiagnostics(), m = /* @__PURE__ */ new Set();
-  return p.forEach((a) => {
-    a.file === u && a.start !== void 0 && m.add(u.getLineAndCharacterOfPosition(a.start).line);
-  }), s.map((a, i) => {
-    const g = `const check${i}: TargetType = {} as F${i};`, T = c.split(`
-`).findIndex((h) => h.includes(g));
-    return T !== -1 && m.has(T) ? null : {
-      __typename: "NodeFunction",
-      id: "gid://sagittarius/NodeFunction/1",
-      functionDefinition: {
-        __typename: "FunctionDefinition",
-        id: a.identifier,
-        identifier: a.identifier
-      },
-      parameters: {
-        __typename: "NodeParameterConnection",
-        nodes: (a.parameterDefinitions?.nodes || []).map((h) => ({
-          __typename: "NodeParameter",
-          parameterDefinition: {
-            __typename: "ParameterDefinition",
-            id: h?.identifier,
-            identifier: h?.identifier
-          },
-          value: null
-        }))
-      }
-    };
-  }).filter((a) => a !== null);
-}
-const W = (n, s, r, e) => {
-  const c = new Map(r.map((F) => [F.identifier, F])).get(s.functionDefinition?.identifier);
-  if (!c)
+}, z = (e, t, n, r) => {
+  const s = new Map(n?.map((F) => [F.identifier, F])).get(t?.functionDefinition?.identifier);
+  if (!s)
     return {
       isValid: !1,
-      inferredType: "any",
-      errors: [{ message: `Function ${s.id} not found`, code: 404, severity: "error" }]
+      returnType: "any",
+      diagnostics: [{ message: `Function ${t?.id} not found`, nodeId: t?.id, code: 404, severity: "error" }]
     };
-  const u = s.parameters?.nodes || [], d = [];
-  for (const F of u) {
-    const S = F.value;
-    if (S?.__typename === "ReferenceValue") {
-      const $ = z(n, s, S);
-      $.isValid || d.push({
-        message: $.error || "Scope error",
+  const c = t?.parameters?.nodes || [], a = [];
+  for (const F of c) {
+    const N = F.value;
+    if (N?.__typename === "ReferenceValue") {
+      const x = se(e, t, N);
+      x.isValid || a.push({
+        message: x.error || "Scope error",
         code: 403,
+        nodeId: t?.id,
+        parameterIndex: c.indexOf(F),
         severity: "error"
       });
     }
   }
-  if (d.length > 0)
+  if (a.length > 0)
     return {
       isValid: !1,
-      inferredType: "any",
-      errors: d
+      returnType: "any",
+      diagnostics: a
     };
-  const p = u.map((F) => K(F, n, (S, $) => W(S, $, r, e))).map(
+  const u = c.map((F) => q(F, e, (N, x) => z(N, x, n, r))), p = u.map(
     (F) => F === "undefined" ? "({} as any)" : F
   ).join(", ");
-  let m = c.signature;
-  const a = `
-        ${E(e)}
-        declare function testFunc${m};
+  let l = s.signature;
+  const h = `
+        ${V(r)}
+        declare function testFunc${l};
         const result = testFunc(${p});
-    `, i = "node_virtual.ts", g = t.createSourceFile(i, a, t.ScriptTarget.Latest), _ = I(i, a, g), T = t.createProgram([i], x, _), h = T.getTypeChecker(), f = T.getSemanticDiagnostics(g);
-  let N = "any";
-  const l = (F) => {
-    if (t.isVariableDeclaration(F) && F.name.getText() === "result") {
-      const S = h.getTypeAtLocation(F);
-      N = h.typeToString(
-        S,
+    `, i = "index.ts", f = I(i, h), v = f.getSourceFile(i), d = f.languageService.getProgram(), T = d.getTypeChecker(), g = d.getSemanticDiagnostics(v);
+  let S = "any";
+  const m = (F) => {
+    if (y.isVariableDeclaration(F) && F.name.getText() === "result") {
+      const N = T.getTypeAtLocation(F);
+      S = T.typeToString(
+        N,
         F,
-        t.TypeFormatFlags.NoTruncation | t.TypeFormatFlags.UseFullyQualifiedType
+        y.TypeFormatFlags.NoTruncation | y.TypeFormatFlags.UseFullyQualifiedType
       );
     }
-    t.forEachChild(F, l);
+    y.forEachChild(F, m);
   };
-  l(g);
-  const v = f.map((F) => {
-    const S = t.flattenDiagnosticMessageText(F.messageText, `
-`), $ = /\b([TRKV])\b/.test(S), C = S.includes("not assignable to parameter of type") && (S.includes("'{}'") || S.includes("undefined")) || S.includes("not assignable to type 'undefined'") || S.includes("not assignable to type 'void'") || S.includes("may be a mistake because neither type sufficiently overlaps");
+  m(v);
+  const $ = g.map((F) => {
+    const N = y.flattenDiagnosticMessageText(F.messageText, `
+`), x = /\b([TRKV])\b/.test(N), C = N.includes("not assignable to parameter of type") && (N.includes("'{}'") || N.includes("undefined")) || N.includes("not assignable to type 'undefined'") || N.includes("not assignable to type 'void'") || N.includes("may be a mistake because neither type sufficiently overlaps");
     return {
-      message: S,
+      message: N,
       code: F.code,
-      severity: $ || C ? "warning" : "error"
+      nodeId: t?.id,
+      parameterIndex: (() => {
+        if (F.start !== void 0) {
+          const P = c.findIndex((M, L) => {
+            const b = h.indexOf(u[L]);
+            return F.start >= b && F.start < b + u[L].length;
+          });
+          if (P !== -1) return P;
+        }
+      })(),
+      severity: x || C ? "warning" : "error"
     };
   });
   return {
-    isValid: !v.some((F) => F.severity === "error"),
-    inferredType: N,
-    errors: v
+    isValid: !$.some((F) => F.severity === "error"),
+    returnType: S,
+    diagnostics: $
   };
-}, ee = (n, s, r, e, o) => {
-  const c = [], u = n.nodes?.nodes || [], d = u.find((i) => i?.id === s);
-  if (!d) return [];
-  const y = E(o), p = (i, g) => {
-    if (!r || r === "any" || i === "any") return !0;
-    const _ = `suggestion_check_${Math.random().toString(36).substring(7)}.ts`, T = `
-            ${y}
+}, pe = (e, t, n) => {
+  const o = new Map(t?.map((m) => [m.identifier, m])).get(e?.functionDefinition?.identifier);
+  if (!o)
+    return {
+      parameters: [],
+      returnType: "any"
+    };
+  const s = {
+    id: "gid://sagittarius/Flow/0",
+    nodes: { __typename: "NodeFunctionConnection", nodes: [e] }
+  }, u = (e?.parameters?.nodes || []).map((m) => q(m, s, ($, F) => z($, F, t, n))).map((m) => m === "undefined" ? "({} as any)" : m).join(", "), p = o.signature, l = `
+        ${V(n)}
+        declare function testFunc${p};
+        const result = testFunc(${u});
+    `, h = "index.ts", i = I(h, l), f = i.getSourceFile(h), d = i.languageService.getProgram().getTypeChecker();
+  let T = "any", g = [];
+  const S = (m) => {
+    if (y.isVariableDeclaration(m) && m.name.getText() === "result") {
+      const $ = d.getTypeAtLocation(m);
+      if (T = d.typeToString(
+        $,
+        m,
+        y.TypeFormatFlags.NoTruncation
+      ), y.isCallExpression(m.initializer)) {
+        const F = m.initializer, N = d.getResolvedSignature(F);
+        N && (g = N.getParameters().map((x) => {
+          const C = d.getTypeOfSymbolAtLocation(x, F);
+          return d.typeToString(
+            C,
+            F,
+            y.TypeFormatFlags.NoTruncation
+          );
+        }));
+      }
+    }
+    y.forEachChild(m, S);
+  };
+  return S(f), {
+    parameters: g,
+    returnType: T
+  };
+}, me = (e, t, n) => {
+  let r = t;
+  if (e && t) {
+    let o = function(i) {
+      const f = i.match(/<([^>]+)>/);
+      return f ? f[1].split(",").map((v) => v.trim()).filter(Boolean).length : 0;
+    };
+    const s = `
+        ${V(n)}
+        type TargetType = ${e};
+        ${t?.map((i, f) => `
+                declare function Fu${f}${i.signature};
+                type F${f} = ReturnType<typeof Fu${f}${o(i.signature) > 0 ? `<${Array(o(i.signature)).fill("any").join(", ")}>` : ""}>;
+            `).join(`
+`)}
+        ${t?.map((i, f) => `const check${f}: TargetType = {} as F${f};`).join(`
+`)}
+    `, c = "index.ts", a = I(c, s), u = a.getSourceFile(c), l = a.languageService.getProgram().getSemanticDiagnostics(), h = /* @__PURE__ */ new Set();
+    l.forEach((i) => {
+      i.file === u && i.start !== void 0 && h.add(u.getLineAndCharacterOfPosition(i.start).line);
+    }), r = t.filter((i, f) => {
+      const v = `const check${f}: TargetType = {} as F${f};`, T = s.split(`
+`).findIndex((g) => g.includes(v));
+      return T !== -1 && !h.has(T);
+    });
+  }
+  return r?.map((o) => ({
+    __typename: "NodeFunction",
+    id: "gid://sagittarius/NodeFunction/1",
+    functionDefinition: {
+      __typename: "FunctionDefinition",
+      id: o.identifier,
+      identifier: o.identifier
+    },
+    parameters: {
+      __typename: "NodeParameterConnection",
+      nodes: (o.parameterDefinitions?.nodes || []).map((s) => ({
+        __typename: "NodeParameter",
+        parameterDefinition: {
+          __typename: "ParameterDefinition",
+          id: s?.identifier,
+          identifier: s?.identifier
+        },
+        value: null
+      }))
+    }
+  })).filter((o) => o !== null) ?? [];
+}, ye = (e, t, n = "any", r, o) => {
+  if (!e) return [];
+  if (!t) return [];
+  const s = [], c = e?.nodes?.nodes || [], a = c.find((i) => i?.id === t);
+  if (!a) return [];
+  const u = V(o), p = (i, f) => {
+    if (!n || n === "any" || i === "any") return !0;
+    const v = "index.ts", d = `
+            ${u}
             const val: ${i} = {} as any;
-            const test: ${r} = val${g ? `.${g}` : ""};
-        `, h = t.createSourceFile(_, T, t.ScriptTarget.Latest), f = I(_, T, h);
-    return !t.createProgram([_], x, f).getSemanticDiagnostics(h).some((v) => v.category === t.DiagnosticCategory.Error);
-  }, m = (i, g) => {
-    const _ = [], T = `probing_${Math.random().toString(36).substring(7)}.ts`, h = `
-            ${y}
+            const test: ${n} = val${f ? `.${f}` : ""};
+        `, T = I(v, d), g = T.getSourceFile(v);
+    return !T.languageService.getProgram().getSemanticDiagnostics(g).some(($) => $.category === y.DiagnosticCategory.Error);
+  }, l = (i, f) => {
+    const v = [], d = "index.ts", T = `
+            ${u}
             const val: ${i} = {} as any;
-        `, f = t.createSourceFile(T, h, t.ScriptTarget.Latest), N = I(T, h, f), l = t.createProgram([T], x, N), v = l.getTypeChecker();
-    p(i) && _.push({ ...g, referencePath: [] });
-    const F = ($, C = []) => {
+        `, g = I(d, T), S = g.getSourceFile(d), m = g.languageService.getProgram(), $ = m.getTypeChecker();
+    p(i) && v.push({ ...f, referencePath: [] });
+    const F = (x, C = []) => {
       if (C.length > 3) return;
-      const A = $.getProperties();
-      for (const V of A) {
-        const R = V.getName();
-        let D;
-        if (v.getPropertyOfType) {
-          const b = v.getPropertyOfType($, R);
-          b && (D = v.getTypeOfSymbolAtLocation(b, f));
+      const P = x.getProperties();
+      for (const M of P) {
+        const L = M.getName();
+        let b;
+        if ($.getPropertyOfType) {
+          const _ = $.getPropertyOfType(x, L);
+          _ && (b = $.getTypeOfSymbolAtLocation(_, S));
         } else {
-          const b = $.getProperty(R);
-          b && (D = v.getTypeOfSymbolAtLocation(b, f));
+          const _ = x.getProperty(L);
+          _ && (b = $.getTypeOfSymbolAtLocation(_, S));
         }
-        if (!D) continue;
-        const P = [...C, R], L = P.join(".");
-        p(i, L) && _.push({
-          ...g,
-          referencePath: P.map((b) => ({
+        if (!b) continue;
+        const D = [...C, L], E = D.join(".");
+        p(i, E) && v.push({
+          ...f,
+          referencePath: D.map((_) => ({
             __typename: "ReferencePath",
-            path: b
+            path: _
           }))
-        }), F(D, P);
+        }), F(b, D);
       }
     };
-    if (l.getSemanticDiagnostics(f).length === 0) {
-      let $;
-      const C = (A) => {
-        t.isVariableDeclaration(A) && A.name.getText() === "val" && ($ = v.getTypeAtLocation(A)), t.forEachChild(A, C);
+    if (m.getSemanticDiagnostics(S).length === 0) {
+      let x;
+      const C = (P) => {
+        y.isVariableDeclaration(P) && P.name.getText() === "val" && (x = $.getTypeAtLocation(P)), y.forEachChild(P, C);
       };
-      C(f), $ && F($);
+      C(S), x && F(x);
     }
-    return _;
+    return v;
   };
-  if (n.inputType) {
-    const i = n.inputType.identifier || "any";
-    c.push(...m(i, {
-      __typename: "ReferenceValue",
-      nodeFunctionId: null,
-      parameterIndex: 0,
-      referencePath: []
-    }));
+  if (e.inputType) {
+    const i = e.inputType || "any";
+    s.push(...l(i, {}));
   }
-  u.forEach((i) => {
-    if (!(!i || i.id === s) && H(n, i, d)) {
-      const g = W(n, i, e, o);
-      c.push(...m(g.inferredType, {
+  c.forEach((i) => {
+    if (!(!i || i.id === t) && ue(e, i, a)) {
+      const f = z(e, i, r, o);
+      s.push(...l(f.returnType, {
         __typename: "ReferenceValue",
         nodeFunctionId: i.id,
         referencePath: []
       }));
     }
   });
-  let a = k(n, s);
-  for (; a; ) {
-    if (e.find((g) => g.identifier === a.functionDefinition?.identifier)) {
-      const g = a.parameters?.nodes?.findIndex((_) => {
-        const T = _?.value;
-        if (T?.__typename === "NodeFunctionIdWrapper") {
-          const h = T;
-          return h.id === s || U(n, h.id || void 0, s);
+  let h = O(e, t);
+  for (; h; ) {
+    if (r?.find((f) => f.identifier === h.functionDefinition?.identifier)) {
+      const f = h.parameters?.nodes?.findIndex((v) => {
+        const d = v?.value;
+        if (d?.__typename === "NodeFunctionIdWrapper") {
+          const T = d;
+          return T.id === t || U(e, T.id || void 0, t);
         }
         return !1;
       });
-      g !== void 0 && g !== -1 && c.push(...m("any", {
+      f !== void 0 && f !== -1 && s.push(...l("any", {
         __typename: "ReferenceValue",
-        nodeFunctionId: a.id,
-        parameterIndex: g,
+        nodeFunctionId: h.id,
+        parameterIndex: f,
         inputIndex: 0,
         referencePath: []
       }));
     }
-    a = k(n, a.id);
+    h = O(e, h.id);
   }
-  return c;
+  return s;
 };
-function H(n, s, r) {
-  const e = n.nodes?.nodes || [];
-  let o = s.nextNodeId;
-  const c = /* @__PURE__ */ new Set();
+function ue(e, t, n) {
+  const r = e.nodes?.nodes || [];
+  let o = t.nextNodeId;
+  const s = /* @__PURE__ */ new Set();
   for (; o; ) {
-    if (o === r.id) return !0;
-    if (c.has(o)) break;
-    c.add(o), o = e.find((y) => y?.id === o)?.nextNodeId;
+    if (o === n.id) return !0;
+    if (s.has(o)) break;
+    s.add(o), o = r.find((u) => u?.id === o)?.nextNodeId;
   }
-  let u = k(n, r.id);
-  for (; u; ) {
-    if (u.id === s.id) return !0;
-    u = k(n, u.id);
+  let c = O(e, n.id);
+  for (; c; ) {
+    if (c.id === t.id) return !0;
+    c = O(e, c.id);
   }
   return !1;
 }
-function k(n, s) {
-  return n.nodes?.nodes?.find(
-    (e) => e?.parameters?.nodes?.some(
-      (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === s
+function O(e, t) {
+  return e.nodes?.nodes?.find(
+    (r) => r?.parameters?.nodes?.some(
+      (o) => o?.value?.__typename === "NodeFunctionIdWrapper" && o.value.id === t
     )
   ) || void 0;
 }
-function U(n, s, r) {
-  if (!s) return !1;
-  if (s === r) return !0;
-  const o = (n.nodes?.nodes || []).find((u) => u?.id === s);
-  return o ? o.nextNodeId && U(n, o.nextNodeId || void 0, r) ? !0 : !!o.parameters?.nodes?.some((u) => {
-    const d = u?.value;
-    return d?.__typename === "NodeFunctionIdWrapper" ? U(n, d.id || void 0, r) : !1;
+function U(e, t, n) {
+  if (!t) return !1;
+  if (t === n) return !0;
+  const o = (e.nodes?.nodes || []).find((c) => c?.id === t);
+  return o ? o.nextNodeId && U(e, o.nextNodeId || void 0, n) ? !0 : !!o.parameters?.nodes?.some((c) => {
+    const a = c?.value;
+    return a?.__typename === "NodeFunctionIdWrapper" ? U(e, a.id || void 0, n) : !1;
   }) : !1;
 }
-const te = (n) => {
-  const r = `const tempValue = ${JSON.stringify(n.value)};`, e = "temp_value.ts", o = t.createSourceFile(e, r, t.ScriptTarget.Latest), c = I(e, r, o), d = t.createProgram([e], { target: t.ScriptTarget.Latest, noEmit: !0 }, c).getTypeChecker();
-  let y = "any";
-  const p = (m) => {
-    if (t.isVariableDeclaration(m) && m.name.getText() === "tempValue") {
-      const a = d.getTypeAtLocation(m);
-      y = d.typeToString(
-        a,
-        m,
-        t.TypeFormatFlags.NoTruncation | t.TypeFormatFlags.UseFullyQualifiedType
-      );
-    }
-    t.forEachChild(m, p);
-  };
-  return p(o), y;
-};
-var q = /* @__PURE__ */ ((n) => (n[n.PRIMITIVE = 0] = "PRIMITIVE", n[n.TYPE = 1] = "TYPE", n[n.ARRAY = 2] = "ARRAY", n[n.OBJECT = 3] = "OBJECT", n))(q || {});
-const ne = (n, s) => {
-  const r = E(s), e = `type_probe_${Math.random().toString(36).substring(7)}.ts`, o = `
-        ${r}
-        type TargetType = ${n};
-        const val: TargetType = {} as any;
-    `, c = t.createSourceFile(e, o, t.ScriptTarget.Latest), u = I(e, o, c), y = t.createProgram([e], x, u).getTypeChecker();
-  let p = 1;
-  const m = (a) => {
-    if (t.isVariableDeclaration(a) && a.name.getText() === "val") {
-      const i = y.getTypeAtLocation(a);
-      y.isArrayType(i) ? p = 2 : i.isStringLiteral() || i.isNumberLiteral() || (i.getFlags() & (t.TypeFlags.String | t.TypeFlags.Number | t.TypeFlags.Boolean | t.TypeFlags.EnumLiteral | t.TypeFlags.BigInt | t.TypeFlags.ESSymbol)) !== 0 ? p = 0 : (i.isClassOrInterface() || (i.getFlags() & t.TypeFlags.Object) !== 0) && i.getProperties().length > 0 ? p = 3 : p = 1;
-    }
-    t.forEachChild(a, m);
-  };
-  return m(c), p;
-}, re = (n, s) => {
-  const r = `
-        ${E(s)}
-        type Target = ${n};
-    `, e = "temp_type_to_value.ts", o = t.createSourceFile(e, r, t.ScriptTarget.Latest, !0), c = I(e, r, o), d = t.createProgram([e], x, c).getTypeChecker(), y = o.statements.find(
-    (i) => t.isTypeAliasDeclaration(i) && i.name.text === "Target"
-  );
-  if (!y)
-    return { __typename: "LiteralValue", value: null };
-  const p = d.getTypeAtLocation(y.type), m = (i, g, _ = /* @__PURE__ */ new Set()) => {
-    if (_.has(i)) return null;
-    _.add(i);
-    const T = i.getFlags();
-    if (i.isUnion()) {
-      if (g.type, t.isTypeAliasDeclaration(g) && g.type && t.isUnionTypeNode(g.type)) {
-        const N = d.getTypeFromTypeNode(g.type.types[0]);
-        return m(N, g, _);
+const ve = (e, t) => {
+  if (!e) return [];
+  const n = `
+        ${V(t)}
+        type T = ${e}; const val: T = {} as any;
+    `, r = "index.ts", o = I(r, n), s = o.getSourceFile(r), a = o.languageService.getProgram().getTypeChecker(), u = s.statements.find(y.isTypeAliasDeclaration);
+  if (!u) return [];
+  const p = a.getTypeAtLocation(u), l = (i) => i.isUnion() ? i.types.flatMap(l) : i.isStringLiteral() ? [i.value] : i.isNumberLiteral() ? [i.value.toString()] : i.intrinsicName === "true" ? ["true"] : i.intrinsicName === "false" ? ["false"] : [];
+  return Array.from(new Set(l(p))).map((i) => ({
+    __typename: "LiteralValue",
+    value: i
+  }));
+}, k = (e) => e.replace(/[^a-zA-Z0-9]/g, "_"), Fe = (e, t, n) => {
+  const r = /* @__PURE__ */ new Set(), o = e?.nodes?.nodes || [], s = new Map(t?.map((g) => [g.identifier, g])), c = (g, S = "") => {
+    if (r.has(g)) return "";
+    const m = o.find((L) => L?.id === g);
+    if (!m || !m.functionDefinition) return "";
+    r.add(g);
+    const $ = s.get(m.functionDefinition?.identifier);
+    if (!$) return `${S}// Error: Function ${m.functionDefinition.identifier} not found
+`;
+    const N = (m.parameters?.nodes || []).map((L, b) => {
+      const D = L.value;
+      if (!D) return "undefined";
+      if (D.__typename === "ReferenceValue") {
+        const E = D;
+        if (!E.nodeFunctionId) return "undefined";
+        let _ = E.parameterIndex !== void 0 ? `/* @pos ${g} ${b} */ p_${k(E.nodeFunctionId)}_${E.parameterIndex}` : `/* @pos ${g} ${b} */ node_${k(E.nodeFunctionId)}`;
+        return E.referencePath?.forEach((j) => {
+          _ += `?.${j.path}`;
+        }), _;
       }
-      const h = i.types.filter((N) => {
-        const l = N.getFlags();
-        return !(l & t.TypeFlags.Undefined) && !(l & t.TypeFlags.Null);
-      }), f = h.length > 0 ? h[0] : i.types[0];
-      return m(f, g, _);
-    }
-    if (T & t.TypeFlags.StringLiteral) return i.value;
-    if (T & t.TypeFlags.String) return "sample";
-    if (T & t.TypeFlags.NumberLiteral) return i.value;
-    if (T & t.TypeFlags.Number) return 1;
-    if (T & t.TypeFlags.BooleanLiteral) return i.intrinsicName === "true";
-    if (T & t.TypeFlags.Boolean) return !1;
-    if (d.isArrayType(i)) {
-      const f = i.typeArguments?.[0] || d.getAnyType();
-      return [m(f, g, _)];
-    }
-    if (i.isClassOrInterface() || T & t.TypeFlags.Object || i.getProperties().length > 0) {
-      const h = {};
-      return i.getProperties().forEach((N) => {
-        const l = d.getTypeOfSymbolAtLocation(N, g);
-        l && (h[N.getName()] = m(l, g, _));
-      }), h;
+      if (D.__typename === "LiteralValue")
+        return `/* @pos ${g} ${b} */ ${JSON.stringify(D.value)}`;
+      if (D.__typename === "NodeFunctionIdWrapper") {
+        const E = D, _ = `p_${k(m.id)}_${b}`, j = c(E.id, S + "  ");
+        return `/* @pos ${g} ${b} */ (${_}) => {
+${j}${S}}`;
+      }
+      return "undefined";
+    }).join(", "), x = `node_${k(m.id)}`, C = `fn_${$.identifier?.replace(/::/g, "_")}`, P = N.includes("undefined");
+    let M = `${S}const ${x} = ${C}(${N})${P ? " as any" : ""} ;
+`;
+    return m.nextNodeId && (M += c(m.nextNodeId, S)), M;
+  }, a = V(n), u = t?.map((g) => `declare function fn_${g.identifier?.replace(/::/g, "_")}${g.signature}`).join(`
+`), p = o.map((g) => g?.id ? c(g.id) : "").filter((g) => g !== "").join(`
+`), l = `${a}
+${u}
+
+// --- Flow ---
+${p}`, h = "index.ts", i = I(h, l), f = i.getSourceFile(h), T = i.languageService.getProgram().getSemanticDiagnostics(f).map((g) => {
+    const S = Z(g.messageText, `
+`);
+    if (S.includes("Argument of type 'undefined'") || S.includes("not assignable to type 'undefined'")) return null;
+    let $, F;
+    if (g.start !== void 0) {
+      const C = f.getFullText().substring(0, g.start).match(/\/\* @pos ([^ ]+) (\d+) \*\/\s*$/);
+      C && ($ = C[1], F = parseInt(C[2], 10));
     }
-    return null;
-  };
+    return {
+      message: S,
+      code: g.code,
+      severity: "error",
+      nodeId: $,
+      parameterIndex: F
+    };
+  }).filter((g) => g !== null);
   return {
-    value: m(p, y)
+    isValid: !T.some((g) => g?.severity === "error"),
+    returnType: "void",
+    diagnostics: T
   };
-}, ie = (n) => {
-  if (!n) return [];
-  const s = `type T = ${n}; const val: T = {} as any;`, r = "suggestions_virtual.ts", e = t.createSourceFile(r, s, t.ScriptTarget.Latest), o = I(r, s, e), u = t.createProgram([r], { ...x, noLib: !0 }, o).getTypeChecker(), d = e.statements.find(t.isTypeAliasDeclaration);
-  if (!d) return [];
-  const y = u.getTypeAtLocation(d), p = (a) => a.isUnion() ? a.types.flatMap(p) : a.isStringLiteral() ? [a.value] : a.isNumberLiteral() ? [a.value.toString()] : a.intrinsicName === "true" ? ["true"] : a.intrinsicName === "false" ? ["false"] : [];
-  return Array.from(new Set(p(y))).map((a) => ({
-    __typename: "LiteralValue",
-    value: a
-  }));
-}, se = (n, s, r) => {
-  const e = JSON.stringify(s.value), o = `
-        ${E(r)}
-        const testValue: ${n} = ${e};
-    `, c = "value_check.ts", u = t.createSourceFile(c, o, t.ScriptTarget.Latest), d = I(c, o, u), p = t.createProgram([c], x, d).getSemanticDiagnostics(u);
-  return p.length > 0 ? {
-    isValid: !1,
-    error: t.flattenDiagnosticMessageText(p[0].messageText, `
-`)
-  } : { isValid: !0 };
-}, oe = (n, s, r) => {
-  const o = new Map(s.map((l) => [l.identifier, l])).get(n.functionDefinition?.identifier);
-  if (!o)
+}, he = (e, t, n) => {
+  const r = JSON.stringify(t?.value), o = `
+        ${V(n)}
+        const testValue: ${e} = ${r};
+    `, s = "index.ts", u = I(s, o).languageService.getSemanticDiagnostics(s).map((p) => {
+    const l = y.flattenDiagnosticMessageText(p.messageText, `
+`), h = /\b([TRKV])\b/.test(l), i = l.includes("not assignable to parameter of type") && (l.includes("'{}'") || l.includes("undefined")) || l.includes("not assignable to type 'undefined'") || l.includes("not assignable to type 'void'") || l.includes("may be a mistake because neither type sufficiently overlaps");
     return {
-      parameters: [],
-      returnType: "any"
+      message: l,
+      code: p.code,
+      severity: h || i ? "warning" : "error"
     };
-  const c = {
-    id: "gid://sagittarius/Flow/0",
-    nodes: { __typename: "NodeFunctionConnection", nodes: [n] }
-  }, y = (n.parameters?.nodes || []).map((l) => K(l, c, (v, F) => W(v, F, s, r))).map((l) => l === "undefined" ? "({} as any)" : l).join(", "), p = o.signature, m = `
-        ${E(r)}
-        declare function testFunc${p};
-        const result = testFunc(${y});
-    `, a = "node_types_virtual.ts", i = t.createSourceFile(a, m, t.ScriptTarget.Latest), g = I(a, m, i), T = t.createProgram([a], x, g).getTypeChecker();
-  let h = "any", f = [];
-  const N = (l) => {
-    if (t.isVariableDeclaration(l) && l.name.getText() === "result") {
-      const v = T.getTypeAtLocation(l);
-      if (h = T.typeToString(
-        v,
-        l,
-        t.TypeFormatFlags.NoTruncation
-      ), t.isCallExpression(l.initializer)) {
-        const F = l.initializer, S = T.getResolvedSignature(F);
-        S && (f = S.getParameters().map(($) => {
-          const C = T.getTypeOfSymbolAtLocation($, F);
-          return T.typeToString(
-            C,
-            F,
-            t.TypeFormatFlags.NoTruncation
-          );
-        }));
-      }
-    }
-    t.forEachChild(l, N);
-  };
-  return N(i), {
-    parameters: f,
-    returnType: h
+  });
+  return {
+    isValid: !u.some((p) => p.severity === "error"),
+    returnType: "void",
+    diagnostics: u
   };
 };
 export {
-  q as DataTypeVariant,
-  Z as getFlowValidation,
-  X as getNodeSuggestions,
-  W as getNodeValidation,
-  ee as getReferenceSuggestions,
-  te as getTypeFromValue,
-  ne as getTypeVariant,
-  oe as getTypesFromNode,
-  re as getValueFromType,
-  ie as getValueSuggestions,
-  se as getValueValidation
+  ce as DataTypeVariant,
+  Fe as getFlowValidation,
+  me as getNodeSuggestions,
+  z as getNodeValidation,
+  ye as getReferenceSuggestions,
+  fe as getTypeFromValue,
+  de as getTypeVariant,
+  pe as getTypesFromNode,
+  ge as getValueFromType,
+  ve as getValueSuggestions,
+  he as getValueValidation
 };