@sandstone-mc/mcdoc-ts-generator 0.1.8 → 0.1.10

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { dirname, resolve } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
+import { pathToFileURL } from "url";
 import { promisify } from "util";
 import * as fs2 from "fs";
 import {
@@ -198,12 +198,17 @@ function add_import(imports, add_import2) {
   }
   return imports;
 }
-function merge_imports(imports, new_imports) {
+function merge_imports(imports, new_imports, filter) {
   if (imports === undefined) {
-    return new_imports;
+    if (filter === undefined) {
+      return new_imports;
+    }
   }
   for (const import_path of new_imports.ordered) {
-    if (!imports.check.has(import_path)) {
+    if (filter?.has(import_path)) {
+      continue;
+    }
+    if (imports === undefined || !imports.check.has(import_path)) {
       imports = add_import(imports, import_path);
     }
   }
@@ -2232,41 +2237,38 @@ var SimpleKeyIndex = JSON.stringify([{
 }]);
 var Fallback = Bind.StringLiteral("%fallback");
 var None = Bind.StringLiteral("%none");
-function DispatcherGeneric(registry, args) {
-  return factory21.createTypeReferenceNode("Dispatcher", [
-    Bind.StringLiteral(registry),
-    factory21.createTupleTypeNode(args)
-  ]);
+function SymbolGeneric(symbol_name, generics, case_arg) {
+  return factory21.createTypeReferenceNode(symbol_name, [...generics, case_arg]);
 }
-function DispatcherMapIndex(registry, key, generics) {
-  const dispatcher = factory21.createTypeReferenceNode("Dispatcher", [Bind.StringLiteral(registry), ...generics.length === 0 ? [] : [factory21.createTupleTypeNode(generics)]]);
+function SymbolMapIndex(symbol_name, key, generics) {
+  const symbol_type = factory21.createTypeReferenceNode(symbol_name, generics.length === 0 ? undefined : generics);
   if (key.kind === ts22.SyntaxKind.LiteralType) {
-    return factory21.createIndexedAccessTypeNode(dispatcher, key);
+    return factory21.createIndexedAccessTypeNode(symbol_type, key);
   }
-  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, dispatcher), factory21.createIndexedAccessTypeNode(dispatcher, key), factory21.createTypeReferenceNode("Record", [
+  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, symbol_type), factory21.createIndexedAccessTypeNode(symbol_type, key), factory21.createTypeReferenceNode("Record", [
     factory21.createKeywordTypeNode(ts22.SyntaxKind.StringKeyword),
     factory21.createKeywordTypeNode(ts22.SyntaxKind.UnknownKeyword)
   ])));
 }
-function DispatcherMapSubIndex(registry, member_key, generics, sub_index) {
-  const dispatcher = factory21.createTypeReferenceNode("Dispatcher", [Bind.StringLiteral(registry), ...generics.length === 0 ? [] : [factory21.createTupleTypeNode(generics)]]);
-  const dispatcher_member = factory21.createIndexedAccessTypeNode(dispatcher, member_key);
-  let indexed_dispatcher = undefined;
+function SymbolMapSubIndex(symbol_name, member_key, generics, sub_index) {
+  const symbol_type = factory21.createTypeReferenceNode(symbol_name, generics.length === 0 ? undefined : generics);
+  const symbol_member = factory21.createIndexedAccessTypeNode(symbol_type, member_key);
+  let indexed_symbol = undefined;
   for (let i = sub_index.length;i > 0; i--) {
     const key = Bind.StringLiteral(sub_index[i - 1]);
-    let index_stack = dispatcher_member;
+    let index_stack = symbol_member;
     for (let j = 0;j < i - 1; j++) {
       index_stack = factory21.createIndexedAccessTypeNode(index_stack, Bind.StringLiteral(sub_index[j]));
     }
-    if (indexed_dispatcher === undefined) {
-      indexed_dispatcher = factory21.createIndexedAccessTypeNode(index_stack, key);
+    if (indexed_symbol === undefined) {
+      indexed_symbol = factory21.createIndexedAccessTypeNode(index_stack, key);
     }
-    indexed_dispatcher = factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, index_stack), indexed_dispatcher, factory21.createTypeReferenceNode("Record", [
+    indexed_symbol = factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, index_stack), indexed_symbol, factory21.createTypeReferenceNode("Record", [
       factory21.createKeywordTypeNode(ts22.SyntaxKind.StringKeyword),
       factory21.createKeywordTypeNode(ts22.SyntaxKind.UnknownKeyword)
     ])));
   }
-  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(member_key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, dispatcher), indexed_dispatcher, factory21.createTypeReferenceNode("Record", [
+  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(member_key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, symbol_type), indexed_symbol, factory21.createTypeReferenceNode("Record", [
     factory21.createKeywordTypeNode(ts22.SyntaxKind.StringKeyword),
     factory21.createKeywordTypeNode(ts22.SyntaxKind.UnknownKeyword)
   ])));
@@ -2278,34 +2280,39 @@ function mcdoc_dispatcher(type) {
   const indices = dispatcher.parallelIndices;
   return (args) => {
     DispatcherArgs(args);
-    const dispatcher_import = `::java::dispatcher::Dispatcher`;
+    const info = args.dispatcher_info?.get(registry);
+    if (!info) {
+      throw new Error(`[mcdoc_dispatcher] Unknown dispatcher: ${registry}`);
+    }
+    const { symbol_name } = info;
+    const import_path = `::java::dispatcher::${symbol_name}`;
     let result_type;
     let child_dispatcher;
     const generics = args.generic_types ?? [];
     if (indices.length === 1 && indices[0].kind === "dynamic" && typeof indices[0].accessor.at(-1) === "string") {
       if (args.root_type) {
-        result_type = DispatcherGeneric(registry, [...generics, Fallback]);
+        result_type = SymbolGeneric(symbol_name, generics, Fallback);
       } else {
         child_dispatcher = [[indices[0].accessor.length - 1, indices[0].accessor.at(-1)]];
-        const indexed_type = DispatcherMapIndex(registry, factory21.createTypeReferenceNode("S"), generics);
+        const indexed_type = SymbolMapIndex(symbol_name, factory21.createTypeReferenceNode("S"), generics);
         const properties = args.dispatcher_properties?.get(registry);
         if (properties?.supports_none) {
-          result_type = factory21.createParenthesizedType(factory21.createConditionalTypeNode(factory21.createTypeReferenceNode("S"), factory21.createKeywordTypeNode(ts22.SyntaxKind.UndefinedKeyword), DispatcherGeneric(registry, [...generics, None]), indexed_type));
+          result_type = factory21.createParenthesizedType(factory21.createConditionalTypeNode(factory21.createTypeReferenceNode("S"), factory21.createKeywordTypeNode(ts22.SyntaxKind.UndefinedKeyword), SymbolGeneric(symbol_name, generics, None), indexed_type));
         } else {
           result_type = indexed_type;
         }
       }
     } else if (indices.length === 1 && indices[0].kind === "static") {
       if (indices[0].value === "%fallback") {
-        result_type = DispatcherGeneric(registry, [...generics, Fallback]);
+        result_type = SymbolGeneric(symbol_name, generics, Fallback);
       } else {
-        result_type = DispatcherMapIndex(registry, Bind.StringLiteral(indices[0].value), generics);
+        result_type = SymbolMapIndex(symbol_name, Bind.StringLiteral(indices[0].value), generics);
       }
     } else if (JSON.stringify(indices) === SimpleKeyIndex) {
       if (args.index_keys !== undefined) {
-        result_type = DispatcherMapSubIndex(registry, factory21.createTypeReferenceNode("Key"), generics, args.index_keys);
+        result_type = SymbolMapSubIndex(symbol_name, factory21.createTypeReferenceNode("Key"), generics, args.index_keys);
       } else {
-        result_type = DispatcherMapIndex(registry, factory21.createTypeReferenceNode("Key"), generics);
+        result_type = SymbolMapIndex(symbol_name, factory21.createTypeReferenceNode("Key"), generics);
       }
     } else {
       throw new Error(`[mcdoc_dispatcher] Unsupported dispatcher: ${dispatcher}`);
@@ -2313,8 +2320,8 @@ function mcdoc_dispatcher(type) {
     return {
       type: result_type,
       imports: {
-        ordered: [dispatcher_import],
-        check: new Map([[dispatcher_import, 0]])
+        ordered: [import_path],
+        check: new Map([[import_path, 0]])
       },
       ...add({ child_dispatcher })
     };
@@ -2413,9 +2420,11 @@ function get_type_handler(type) {
 import ts24 from "typescript";
 var { factory: factory23 } = ts24;
 var dispatcher_references = new Map;
-function dispatcher_symbol(id, name, members, dispatcher_properties, module_map, symbols) {
+var dispatcher_symbol_paths = new Map;
+function dispatcher_symbol(id, name, members, dispatcher_properties, dispatcher_info, module_map, symbols) {
   let imports = undefined;
   let has_references = false;
+  const self_import = new Set([`::java::dispatcher::Symbol${name}`]);
   const member_types = [];
   const map_properties = [];
   const member_type_refs = [];
@@ -2451,17 +2460,18 @@ function dispatcher_symbol(id, name, members, dispatcher_properties, module_map,
       name: unknown_type_name,
       dispatcher_symbol: add_reference,
       dispatcher_properties,
+      dispatcher_info,
       module_map,
       symbols
     });
     if ("imports" in result) {
-      imports = merge_imports(imports, result.imports);
+      imports = merge_imports(imports, result.imports, self_import);
     }
     fallback_type_name = factory23.createTypeReferenceNode(unknown_type_name, has_generics ? generic_names : undefined);
     if (ts24.isTypeAliasDeclaration(result.type)) {
       member_types.push(result.type);
     } else {
-      member_types.push(factory23.createTypeAliasDeclaration(undefined, unknown_type_name, undefined, result.type));
+      member_types.push(factory23.createTypeAliasDeclaration([factory23.createModifier(ts24.SyntaxKind.ExportKeyword)], unknown_type_name, undefined, result.type));
     }
   }
   const has_none = "%none" in members;
@@ -2473,11 +2483,12 @@ function dispatcher_symbol(id, name, members, dispatcher_properties, module_map,
       name: none_type_name,
       dispatcher_symbol: add_reference,
       dispatcher_properties,
+      dispatcher_info,
       module_map,
       symbols
     });
     if ("imports" in result) {
-      imports = merge_imports(imports, result.imports);
+      imports = merge_imports(imports, result.imports, self_import);
     }
     dispatcher_properties.set(id, {
       supports_none: true
@@ -2500,11 +2511,12 @@ function dispatcher_symbol(id, name, members, dispatcher_properties, module_map,
       name: member_type_name,
       dispatcher_symbol: add_reference,
       dispatcher_properties,
+      dispatcher_info,
       module_map,
       symbols
     });
     if ("imports" in result) {
-      imports = merge_imports(imports, result.imports);
+      imports = merge_imports(imports, result.imports, self_import);
     }
     if (ts24.isTypeAliasDeclaration(result.type)) {
       member_types.push(result.type);
@@ -2545,6 +2557,23 @@ var DispatcherSymbol = dispatcher_symbol;
 import { TaggableResourceLocationCategories } from "@spyglassmc/core";
 import ts25 from "typescript";
 var { factory: factory24 } = ts25;
+function export_dispatchers(paths) {
+  const exports = [];
+  for (const [path, info] of paths) {
+    const relative_path = "./" + path.split("::").slice(2).join("/");
+    const export_specifiers = [
+      factory24.createExportSpecifier(false, undefined, info.symbol_name)
+    ];
+    if (info.has_fallback_type) {
+      export_specifiers.push(factory24.createExportSpecifier(false, undefined, `${info.base_name}FallbackType`));
+    }
+    exports.push(factory24.createExportDeclaration(undefined, false, factory24.createNamedExports(export_specifiers), factory24.createStringLiteral(relative_path, true)));
+  }
+  return {
+    exports,
+    paths: new Set
+  };
+}
 function export_registry(resolved_registries) {
   let imports;
   imports = add_import(imports, "sandstone::Set");
@@ -2564,68 +2593,6 @@ function export_registry(resolved_registries) {
     ...add({ imports })
   };
 }
-function export_dispatcher(resolved_dispatchers) {
-  let imports;
-  const required_args_properties = [];
-  for (const [dispatcher_id, { import_path, generic_count }] of resolved_dispatchers) {
-    imports = add_import(imports, import_path);
-    const tuple_elements = [];
-    for (let i = 0;i < generic_count; i++) {
-      tuple_elements.push(factory24.createKeywordTypeNode(ts25.SyntaxKind.UnknownKeyword));
-    }
-    required_args_properties.push(factory24.createPropertySignature(undefined, factory24.createStringLiteral(dispatcher_id, true), undefined, factory24.createTupleTypeNode(tuple_elements)));
-  }
-  const required_args_type = factory24.createTypeAliasDeclaration(undefined, "DispatcherRequiredArgs", undefined, factory24.createTypeLiteralNode(required_args_properties));
-  const default_args_type = factory24.createTypeAliasDeclaration(undefined, "DefaultArgs", [factory24.createTypeParameterDeclaration(undefined, "R", factory24.createTypeOperatorNode(ts25.SyntaxKind.KeyOfKeyword, factory24.createTypeReferenceNode("DispatcherRequiredArgs")))], factory24.createConditionalTypeNode(factory24.createIndexedAccessTypeNode(factory24.createIndexedAccessTypeNode(factory24.createTypeReferenceNode("DispatcherRequiredArgs"), factory24.createTypeReferenceNode("R")), Bind.StringLiteral("length")), Bind.NumericLiteral(0), factory24.createTupleTypeNode([]), factory24.createKeywordTypeNode(ts25.SyntaxKind.NeverKeyword)));
-  const dispatchers_by_count = new Map;
-  for (const [id, dispatcher] of resolved_dispatchers) {
-    const count = dispatcher.generic_count;
-    if (!dispatchers_by_count.has(count)) {
-      dispatchers_by_count.set(count, []);
-    }
-    dispatchers_by_count.get(count).push([id, dispatcher]);
-  }
-  let apply_dispatcher_body = factory24.createKeywordTypeNode(ts25.SyntaxKind.NeverKeyword);
-  const sorted_counts = [...dispatchers_by_count.keys()].sort((a, b) => b - a);
-  for (const count of sorted_counts) {
-    const dispatchers = dispatchers_by_count.get(count);
-    for (const [dispatcher_id, { symbol_name }] of dispatchers) {
-      const param_names = ["A", "B", "C", "D"].slice(0, count);
-      const infer_params = param_names.map((name) => factory24.createInferTypeNode(factory24.createTypeParameterDeclaration(undefined, name)));
-      const type_refs = param_names.map((name) => factory24.createTypeReferenceNode(name));
-      const map_case = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("Args"), factory24.createTupleTypeNode(infer_params), factory24.createTypeReferenceNode(symbol_name, [...type_refs, Bind.StringLiteral("map")]), factory24.createKeywordTypeNode(ts25.SyntaxKind.NeverKeyword));
-      const none_case = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("Args"), factory24.createTupleTypeNode([...infer_params, Bind.StringLiteral("%none")]), factory24.createTypeReferenceNode(symbol_name, [...type_refs, Bind.StringLiteral("%none")]), map_case);
-      const fallback_case = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("Args"), factory24.createTupleTypeNode([...infer_params, Bind.StringLiteral("%fallback")]), factory24.createTypeReferenceNode(symbol_name, [...type_refs, Bind.StringLiteral("%fallback")]), none_case);
-      apply_dispatcher_body = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("R"), Bind.StringLiteral(dispatcher_id), fallback_case, apply_dispatcher_body);
-    }
-  }
-  const apply_dispatcher_type = factory24.createTypeAliasDeclaration(undefined, "ApplyDispatcher", [
-    factory24.createTypeParameterDeclaration(undefined, "R", factory24.createTypeOperatorNode(ts25.SyntaxKind.KeyOfKeyword, factory24.createTypeReferenceNode("DispatcherRequiredArgs"))),
-    factory24.createTypeParameterDeclaration(undefined, "Args", factory24.createTypeReferenceNode("Array", [
-      factory24.createKeywordTypeNode(ts25.SyntaxKind.UnknownKeyword)
-    ]))
-  ], apply_dispatcher_body);
-  const args_constraint = factory24.createTypeReferenceNode("Array", [
-    factory24.createKeywordTypeNode(ts25.SyntaxKind.UnknownKeyword)
-  ]);
-  const dispatcher_type = factory24.createTypeAliasDeclaration([factory24.createToken(ts25.SyntaxKind.ExportKeyword)], "Dispatcher", [
-    factory24.createTypeParameterDeclaration(undefined, "R", factory24.createTypeOperatorNode(ts25.SyntaxKind.KeyOfKeyword, factory24.createTypeReferenceNode("DispatcherRequiredArgs"))),
-    factory24.createTypeParameterDeclaration(undefined, "Args", args_constraint, factory24.createTypeReferenceNode("DefaultArgs", [factory24.createTypeReferenceNode("R")]))
-  ], factory24.createTypeReferenceNode("ApplyDispatcher", [
-    factory24.createTypeReferenceNode("R"),
-    factory24.createTypeReferenceNode("Args")
-  ]));
-  return {
-    exports: [
-      required_args_type,
-      default_args_type,
-      apply_dispatcher_type,
-      dispatcher_type
-    ],
-    paths: new Set,
-    ...add({ imports })
-  };
-}
 
 // src/typegen/index.ts
 var { factory: factory25 } = ts26;
@@ -2635,6 +2602,7 @@ class TypesGenerator {
   dispatcher_properties = new Map;
   resolved_symbols = new Map;
   resolved_dispatchers = new Map;
+  dispatcher_info = new Map;
   constructor() {}
   resolve_types(symbols, translation_keys) {
     console.log("registries");
@@ -2642,18 +2610,42 @@ class TypesGenerator {
     const registry_exports = export_registry(this.resolved_registries);
     this.resolved_symbols.set("::java::registry", registry_exports);
     const dispatchers = symbols.getVisibleSymbols("mcdoc/dispatcher");
-    for (const id of Object.keys(dispatchers)) {
-      if ("%none" in dispatchers[id].members) {
-        this.dispatcher_properties.set(id, { supports_none: true });
-      }
-    }
+    console.log("dispatcher info");
+    this.precompute_dispatcher_info(dispatchers);
     console.log("modules");
     const module_map = symbols.getVisibleSymbols("mcdoc");
     this.resolve_module_symbols(module_map, symbols);
     console.log("dispatchers");
     this.resolve_dispatcher_symbols(dispatchers, module_map, symbols);
-    const dispatcher_exports = export_dispatcher(this.resolved_dispatchers);
-    this.resolved_symbols.set("mcdoc::dispatcher", dispatcher_exports);
+    const dispatcher_exports = export_dispatchers(dispatcher_symbol_paths);
+    this.resolved_symbols.set("::java::dispatcher", dispatcher_exports);
+  }
+  precompute_dispatcher_info(dispatchers) {
+    for (const id of Object.keys(dispatchers)) {
+      const { members } = dispatchers[id];
+      if (members === undefined) {
+        continue;
+      }
+      if ("%none" in members) {
+        this.dispatcher_properties.set(id, { supports_none: true });
+      }
+      const [namespace, _name] = id.split(":");
+      const name = pascal_case(`${namespace === "mcdoc" ? "mcdoc_" : ""}${_name}`);
+      const symbol_name = `Symbol${name}`;
+      const first_member_key = Object.keys(members).find((k) => !k.startsWith("%"));
+      let generic_count = 0;
+      if (first_member_key) {
+        const first_type = members[first_member_key].data.typeDef;
+        if (first_type.kind === "template") {
+          generic_count = first_type.typeParams.length;
+        }
+      }
+      this.dispatcher_info.set(id, {
+        symbol_name,
+        generic_count,
+        has_fallback_type: "%unknown" in members
+      });
+    }
   }
   resolve_registry_symbols(registries, translation_keys) {
     for (const registry_name of [...AllCategories]) {
@@ -2712,6 +2704,7 @@ class TypesGenerator {
         }
         const resolved_member = get_type_handler(type)(type)({
           dispatcher_properties: this.dispatcher_properties,
+          dispatcher_info: this.dispatcher_info,
           root_type: true,
           name,
           module_path,
@@ -2749,7 +2742,7 @@ class TypesGenerator {
       }
       const [namespace, _name] = id.split(":");
       const name = pascal_case(`${namespace === "mcdoc" ? "mcdoc_" : ""}${_name}`);
-      const { types, imports, references, generic_count } = DispatcherSymbol(id, name, members, this.dispatcher_properties, module_map, symbols);
+      const { types, imports, references, generic_count } = DispatcherSymbol(id, name, members, this.dispatcher_properties, this.dispatcher_info, module_map, symbols);
       let in_module = false;
       const symbol_path = (() => {
         if (namespace === "mcdoc") {
@@ -2764,6 +2757,12 @@ class TypesGenerator {
         }
         return `::java::_dispatcher::${_name}`;
       })();
+      const info = this.dispatcher_info.get(id);
+      dispatcher_symbol_paths.set(symbol_path, {
+        symbol_name: `Symbol${name}`,
+        base_name: name,
+        has_fallback_type: info.has_fallback_type
+      });
       const dispatcher_type_name = `Symbol${name}`;
       this.resolved_dispatchers.set(id, {
         import_path: `${symbol_path}::${dispatcher_type_name}`,
@@ -2774,18 +2773,35 @@ class TypesGenerator {
       if (in_module && this.resolved_symbols.has(symbol_path)) {
         const mod = this.resolved_symbols.get(symbol_path);
         mod.exports.push(...types);
+        let module_has_imports = false;
+        if (mod.imports !== undefined) {
+          module_has_imports = true;
+        }
         if (imports !== undefined) {
-          for (const path of imports.ordered) {
-            if (!mod.paths.has(path)) {
-              mod.imports = add_import(mod.imports, path);
-            }
-          }
+          mod.imports = merge_imports(mod.imports, imports);
+        }
+        if (mod.imports !== undefined) {
+          const same_module_pattern = new RegExp(`^${symbol_path}::[^:]+$`);
+          mod.imports.ordered = mod.imports.ordered.filter((imp) => imp !== `::java::dispatcher::Symbol${name}` && !same_module_pattern.test(imp));
         }
       } else {
+        let filtered_imports = imports;
+        if (imports !== undefined) {
+          const same_module_pattern = new RegExp(`^${symbol_path}::[^:]+$`);
+          const filtered_ordered = imports.ordered.filter((imp) => imp !== `::java::dispatcher::Symbol${name}` && !same_module_pattern.test(imp));
+          if (filtered_ordered.length > 0) {
+            filtered_imports = {
+              ordered: filtered_ordered,
+              check: new Map(filtered_ordered.map((imp, i) => [imp, i]))
+            };
+          } else {
+            filtered_imports = undefined;
+          }
+        }
         this.resolved_symbols.set(symbol_path, {
           exports: types,
           paths: new Set2,
-          ...add({ imports })
+          ...add({ imports: filtered_imports })
         });
       }
     }
@@ -2821,7 +2837,7 @@ var eslint = new ESLint({
         "@stylistic": stylistic
       },
       rules: {
-        "@stylistic/indent": ["error", 4],
+        "@stylistic/indent": ["error", 2],
         "@stylistic/quotes": ["error", "single"],
         "@stylistic/semi": ["error", "never"],
         "@stylistic/member-delimiter-style": ["error", {
@@ -2885,14 +2901,14 @@ function handle_imports(imports) {
     if (path.length === 0) {
       throw new Error(`[mcdoc_import] Import path has no module prefix: "${import_path}"`);
     } else if (path[1] === "java") {
-      file = `sandstone/arguments/generated/${path.slice(2).join("/")}.js`;
+      file = `sandstone/arguments/generated/${path.slice(2).join("/")}.ts`;
     } else if (path[0] === "sandstone") {
       if (path.length === 1) {
         file = "sandstone";
       } else if (path[1] === "arguments" && path.length === 2) {
         file = "sandstone/arguments";
       } else {
-        file = `${path.join("/")}.js`;
+        file = `${path.join("/")}.ts`;
       }
     } else {
       throw new Error(`[mcdoc_import] Unsupported import location "${path[0]}" in "${import_path}"`);
@@ -2924,7 +2940,7 @@ function handle_imports(imports) {
 // src/index.ts
 var writeFile2 = promisify(fs2.writeFile);
 var mkdir2 = promisify(fs2.mkdir);
-var cache_root = join(dirname(fileURLToPath(import.meta.url)), "cache");
+var cache_root = join(process.cwd(), "cache");
 function registerAttributes(meta, release) {
   mcdoc5.runtime.registerAttribute(meta, "since", mcdoc5.runtime.attribute.validator.string, {
     filterElement: () => false

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import { dirname, resolve } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
+import { pathToFileURL } from "url";
 import { promisify } from "util";
 import * as fs2 from "fs";
 import {
@@ -196,12 +196,17 @@ function add_import(imports, add_import2) {
   }
   return imports;
 }
-function merge_imports(imports, new_imports) {
+function merge_imports(imports, new_imports, filter) {
   if (imports === undefined) {
-    return new_imports;
+    if (filter === undefined) {
+      return new_imports;
+    }
   }
   for (const import_path of new_imports.ordered) {
-    if (!imports.check.has(import_path)) {
+    if (filter?.has(import_path)) {
+      continue;
+    }
+    if (imports === undefined || !imports.check.has(import_path)) {
       imports = add_import(imports, import_path);
     }
   }
@@ -2230,41 +2235,38 @@ var SimpleKeyIndex = JSON.stringify([{
 }]);
 var Fallback = Bind.StringLiteral("%fallback");
 var None = Bind.StringLiteral("%none");
-function DispatcherGeneric(registry, args) {
-  return factory21.createTypeReferenceNode("Dispatcher", [
-    Bind.StringLiteral(registry),
-    factory21.createTupleTypeNode(args)
-  ]);
+function SymbolGeneric(symbol_name, generics, case_arg) {
+  return factory21.createTypeReferenceNode(symbol_name, [...generics, case_arg]);
 }
-function DispatcherMapIndex(registry, key, generics) {
-  const dispatcher = factory21.createTypeReferenceNode("Dispatcher", [Bind.StringLiteral(registry), ...generics.length === 0 ? [] : [factory21.createTupleTypeNode(generics)]]);
+function SymbolMapIndex(symbol_name, key, generics) {
+  const symbol_type = factory21.createTypeReferenceNode(symbol_name, generics.length === 0 ? undefined : generics);
   if (key.kind === ts22.SyntaxKind.LiteralType) {
-    return factory21.createIndexedAccessTypeNode(dispatcher, key);
+    return factory21.createIndexedAccessTypeNode(symbol_type, key);
   }
-  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, dispatcher), factory21.createIndexedAccessTypeNode(dispatcher, key), factory21.createTypeReferenceNode("Record", [
+  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, symbol_type), factory21.createIndexedAccessTypeNode(symbol_type, key), factory21.createTypeReferenceNode("Record", [
     factory21.createKeywordTypeNode(ts22.SyntaxKind.StringKeyword),
     factory21.createKeywordTypeNode(ts22.SyntaxKind.UnknownKeyword)
   ])));
 }
-function DispatcherMapSubIndex(registry, member_key, generics, sub_index) {
-  const dispatcher = factory21.createTypeReferenceNode("Dispatcher", [Bind.StringLiteral(registry), ...generics.length === 0 ? [] : [factory21.createTupleTypeNode(generics)]]);
-  const dispatcher_member = factory21.createIndexedAccessTypeNode(dispatcher, member_key);
-  let indexed_dispatcher = undefined;
+function SymbolMapSubIndex(symbol_name, member_key, generics, sub_index) {
+  const symbol_type = factory21.createTypeReferenceNode(symbol_name, generics.length === 0 ? undefined : generics);
+  const symbol_member = factory21.createIndexedAccessTypeNode(symbol_type, member_key);
+  let indexed_symbol = undefined;
   for (let i = sub_index.length;i > 0; i--) {
     const key = Bind.StringLiteral(sub_index[i - 1]);
-    let index_stack = dispatcher_member;
+    let index_stack = symbol_member;
     for (let j = 0;j < i - 1; j++) {
       index_stack = factory21.createIndexedAccessTypeNode(index_stack, Bind.StringLiteral(sub_index[j]));
     }
-    if (indexed_dispatcher === undefined) {
-      indexed_dispatcher = factory21.createIndexedAccessTypeNode(index_stack, key);
+    if (indexed_symbol === undefined) {
+      indexed_symbol = factory21.createIndexedAccessTypeNode(index_stack, key);
     }
-    indexed_dispatcher = factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, index_stack), indexed_dispatcher, factory21.createTypeReferenceNode("Record", [
+    indexed_symbol = factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, index_stack), indexed_symbol, factory21.createTypeReferenceNode("Record", [
       factory21.createKeywordTypeNode(ts22.SyntaxKind.StringKeyword),
       factory21.createKeywordTypeNode(ts22.SyntaxKind.UnknownKeyword)
     ])));
   }
-  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(member_key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, dispatcher), indexed_dispatcher, factory21.createTypeReferenceNode("Record", [
+  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(member_key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, symbol_type), indexed_symbol, factory21.createTypeReferenceNode("Record", [
     factory21.createKeywordTypeNode(ts22.SyntaxKind.StringKeyword),
     factory21.createKeywordTypeNode(ts22.SyntaxKind.UnknownKeyword)
   ])));
@@ -2276,34 +2278,39 @@ function mcdoc_dispatcher(type) {
   const indices = dispatcher.parallelIndices;
   return (args) => {
     DispatcherArgs(args);
-    const dispatcher_import = `::java::dispatcher::Dispatcher`;
+    const info = args.dispatcher_info?.get(registry);
+    if (!info) {
+      throw new Error(`[mcdoc_dispatcher] Unknown dispatcher: ${registry}`);
+    }
+    const { symbol_name } = info;
+    const import_path = `::java::dispatcher::${symbol_name}`;
     let result_type;
     let child_dispatcher;
     const generics = args.generic_types ?? [];
     if (indices.length === 1 && indices[0].kind === "dynamic" && typeof indices[0].accessor.at(-1) === "string") {
       if (args.root_type) {
-        result_type = DispatcherGeneric(registry, [...generics, Fallback]);
+        result_type = SymbolGeneric(symbol_name, generics, Fallback);
       } else {
         child_dispatcher = [[indices[0].accessor.length - 1, indices[0].accessor.at(-1)]];
-        const indexed_type = DispatcherMapIndex(registry, factory21.createTypeReferenceNode("S"), generics);
+        const indexed_type = SymbolMapIndex(symbol_name, factory21.createTypeReferenceNode("S"), generics);
         const properties = args.dispatcher_properties?.get(registry);
         if (properties?.supports_none) {
-          result_type = factory21.createParenthesizedType(factory21.createConditionalTypeNode(factory21.createTypeReferenceNode("S"), factory21.createKeywordTypeNode(ts22.SyntaxKind.UndefinedKeyword), DispatcherGeneric(registry, [...generics, None]), indexed_type));
+          result_type = factory21.createParenthesizedType(factory21.createConditionalTypeNode(factory21.createTypeReferenceNode("S"), factory21.createKeywordTypeNode(ts22.SyntaxKind.UndefinedKeyword), SymbolGeneric(symbol_name, generics, None), indexed_type));
         } else {
           result_type = indexed_type;
         }
       }
     } else if (indices.length === 1 && indices[0].kind === "static") {
       if (indices[0].value === "%fallback") {
-        result_type = DispatcherGeneric(registry, [...generics, Fallback]);
+        result_type = SymbolGeneric(symbol_name, generics, Fallback);
       } else {
-        result_type = DispatcherMapIndex(registry, Bind.StringLiteral(indices[0].value), generics);
+        result_type = SymbolMapIndex(symbol_name, Bind.StringLiteral(indices[0].value), generics);
       }
     } else if (JSON.stringify(indices) === SimpleKeyIndex) {
       if (args.index_keys !== undefined) {
-        result_type = DispatcherMapSubIndex(registry, factory21.createTypeReferenceNode("Key"), generics, args.index_keys);
+        result_type = SymbolMapSubIndex(symbol_name, factory21.createTypeReferenceNode("Key"), generics, args.index_keys);
       } else {
-        result_type = DispatcherMapIndex(registry, factory21.createTypeReferenceNode("Key"), generics);
+        result_type = SymbolMapIndex(symbol_name, factory21.createTypeReferenceNode("Key"), generics);
       }
     } else {
       throw new Error(`[mcdoc_dispatcher] Unsupported dispatcher: ${dispatcher}`);
@@ -2311,8 +2318,8 @@ function mcdoc_dispatcher(type) {
     return {
       type: result_type,
       imports: {
-        ordered: [dispatcher_import],
-        check: new Map([[dispatcher_import, 0]])
+        ordered: [import_path],
+        check: new Map([[import_path, 0]])
       },
       ...add({ child_dispatcher })
     };
@@ -2411,9 +2418,11 @@ function get_type_handler(type) {
 import ts24 from "typescript";
 var { factory: factory23 } = ts24;
 var dispatcher_references = new Map;
-function dispatcher_symbol(id, name, members, dispatcher_properties, module_map, symbols) {
+var dispatcher_symbol_paths = new Map;
+function dispatcher_symbol(id, name, members, dispatcher_properties, dispatcher_info, module_map, symbols) {
   let imports = undefined;
   let has_references = false;
+  const self_import = new Set([`::java::dispatcher::Symbol${name}`]);
   const member_types = [];
   const map_properties = [];
   const member_type_refs = [];
@@ -2449,17 +2458,18 @@ function dispatcher_symbol(id, name, members, dispatcher_properties, module_map,
       name: unknown_type_name,
       dispatcher_symbol: add_reference,
       dispatcher_properties,
+      dispatcher_info,
       module_map,
       symbols
     });
     if ("imports" in result) {
-      imports = merge_imports(imports, result.imports);
+      imports = merge_imports(imports, result.imports, self_import);
     }
     fallback_type_name = factory23.createTypeReferenceNode(unknown_type_name, has_generics ? generic_names : undefined);
     if (ts24.isTypeAliasDeclaration(result.type)) {
       member_types.push(result.type);
     } else {
-      member_types.push(factory23.createTypeAliasDeclaration(undefined, unknown_type_name, undefined, result.type));
+      member_types.push(factory23.createTypeAliasDeclaration([factory23.createModifier(ts24.SyntaxKind.ExportKeyword)], unknown_type_name, undefined, result.type));
     }
   }
   const has_none = "%none" in members;
@@ -2471,11 +2481,12 @@ function dispatcher_symbol(id, name, members, dispatcher_properties, module_map,
       name: none_type_name,
       dispatcher_symbol: add_reference,
       dispatcher_properties,
+      dispatcher_info,
       module_map,
       symbols
     });
     if ("imports" in result) {
-      imports = merge_imports(imports, result.imports);
+      imports = merge_imports(imports, result.imports, self_import);
     }
     dispatcher_properties.set(id, {
       supports_none: true
@@ -2498,11 +2509,12 @@ function dispatcher_symbol(id, name, members, dispatcher_properties, module_map,
       name: member_type_name,
       dispatcher_symbol: add_reference,
       dispatcher_properties,
+      dispatcher_info,
       module_map,
       symbols
     });
     if ("imports" in result) {
-      imports = merge_imports(imports, result.imports);
+      imports = merge_imports(imports, result.imports, self_import);
     }
     if (ts24.isTypeAliasDeclaration(result.type)) {
       member_types.push(result.type);
@@ -2543,6 +2555,23 @@ var DispatcherSymbol = dispatcher_symbol;
 import { TaggableResourceLocationCategories } from "@spyglassmc/core";
 import ts25 from "typescript";
 var { factory: factory24 } = ts25;
+function export_dispatchers(paths) {
+  const exports = [];
+  for (const [path, info] of paths) {
+    const relative_path = "./" + path.split("::").slice(2).join("/");
+    const export_specifiers = [
+      factory24.createExportSpecifier(false, undefined, info.symbol_name)
+    ];
+    if (info.has_fallback_type) {
+      export_specifiers.push(factory24.createExportSpecifier(false, undefined, `${info.base_name}FallbackType`));
+    }
+    exports.push(factory24.createExportDeclaration(undefined, false, factory24.createNamedExports(export_specifiers), factory24.createStringLiteral(relative_path, true)));
+  }
+  return {
+    exports,
+    paths: new Set
+  };
+}
 function export_registry(resolved_registries) {
   let imports;
   imports = add_import(imports, "sandstone::Set");
@@ -2562,68 +2591,6 @@ function export_registry(resolved_registries) {
     ...add({ imports })
   };
 }
-function export_dispatcher(resolved_dispatchers) {
-  let imports;
-  const required_args_properties = [];
-  for (const [dispatcher_id, { import_path, generic_count }] of resolved_dispatchers) {
-    imports = add_import(imports, import_path);
-    const tuple_elements = [];
-    for (let i = 0;i < generic_count; i++) {
-      tuple_elements.push(factory24.createKeywordTypeNode(ts25.SyntaxKind.UnknownKeyword));
-    }
-    required_args_properties.push(factory24.createPropertySignature(undefined, factory24.createStringLiteral(dispatcher_id, true), undefined, factory24.createTupleTypeNode(tuple_elements)));
-  }
-  const required_args_type = factory24.createTypeAliasDeclaration(undefined, "DispatcherRequiredArgs", undefined, factory24.createTypeLiteralNode(required_args_properties));
-  const default_args_type = factory24.createTypeAliasDeclaration(undefined, "DefaultArgs", [factory24.createTypeParameterDeclaration(undefined, "R", factory24.createTypeOperatorNode(ts25.SyntaxKind.KeyOfKeyword, factory24.createTypeReferenceNode("DispatcherRequiredArgs")))], factory24.createConditionalTypeNode(factory24.createIndexedAccessTypeNode(factory24.createIndexedAccessTypeNode(factory24.createTypeReferenceNode("DispatcherRequiredArgs"), factory24.createTypeReferenceNode("R")), Bind.StringLiteral("length")), Bind.NumericLiteral(0), factory24.createTupleTypeNode([]), factory24.createKeywordTypeNode(ts25.SyntaxKind.NeverKeyword)));
-  const dispatchers_by_count = new Map;
-  for (const [id, dispatcher] of resolved_dispatchers) {
-    const count = dispatcher.generic_count;
-    if (!dispatchers_by_count.has(count)) {
-      dispatchers_by_count.set(count, []);
-    }
-    dispatchers_by_count.get(count).push([id, dispatcher]);
-  }
-  let apply_dispatcher_body = factory24.createKeywordTypeNode(ts25.SyntaxKind.NeverKeyword);
-  const sorted_counts = [...dispatchers_by_count.keys()].sort((a, b) => b - a);
-  for (const count of sorted_counts) {
-    const dispatchers = dispatchers_by_count.get(count);
-    for (const [dispatcher_id, { symbol_name }] of dispatchers) {
-      const param_names = ["A", "B", "C", "D"].slice(0, count);
-      const infer_params = param_names.map((name) => factory24.createInferTypeNode(factory24.createTypeParameterDeclaration(undefined, name)));
-      const type_refs = param_names.map((name) => factory24.createTypeReferenceNode(name));
-      const map_case = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("Args"), factory24.createTupleTypeNode(infer_params), factory24.createTypeReferenceNode(symbol_name, [...type_refs, Bind.StringLiteral("map")]), factory24.createKeywordTypeNode(ts25.SyntaxKind.NeverKeyword));
-      const none_case = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("Args"), factory24.createTupleTypeNode([...infer_params, Bind.StringLiteral("%none")]), factory24.createTypeReferenceNode(symbol_name, [...type_refs, Bind.StringLiteral("%none")]), map_case);
-      const fallback_case = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("Args"), factory24.createTupleTypeNode([...infer_params, Bind.StringLiteral("%fallback")]), factory24.createTypeReferenceNode(symbol_name, [...type_refs, Bind.StringLiteral("%fallback")]), none_case);
-      apply_dispatcher_body = factory24.createConditionalTypeNode(factory24.createTypeReferenceNode("R"), Bind.StringLiteral(dispatcher_id), fallback_case, apply_dispatcher_body);
-    }
-  }
-  const apply_dispatcher_type = factory24.createTypeAliasDeclaration(undefined, "ApplyDispatcher", [
-    factory24.createTypeParameterDeclaration(undefined, "R", factory24.createTypeOperatorNode(ts25.SyntaxKind.KeyOfKeyword, factory24.createTypeReferenceNode("DispatcherRequiredArgs"))),
-    factory24.createTypeParameterDeclaration(undefined, "Args", factory24.createTypeReferenceNode("Array", [
-      factory24.createKeywordTypeNode(ts25.SyntaxKind.UnknownKeyword)
-    ]))
-  ], apply_dispatcher_body);
-  const args_constraint = factory24.createTypeReferenceNode("Array", [
-    factory24.createKeywordTypeNode(ts25.SyntaxKind.UnknownKeyword)
-  ]);
-  const dispatcher_type = factory24.createTypeAliasDeclaration([factory24.createToken(ts25.SyntaxKind.ExportKeyword)], "Dispatcher", [
-    factory24.createTypeParameterDeclaration(undefined, "R", factory24.createTypeOperatorNode(ts25.SyntaxKind.KeyOfKeyword, factory24.createTypeReferenceNode("DispatcherRequiredArgs"))),
-    factory24.createTypeParameterDeclaration(undefined, "Args", args_constraint, factory24.createTypeReferenceNode("DefaultArgs", [factory24.createTypeReferenceNode("R")]))
-  ], factory24.createTypeReferenceNode("ApplyDispatcher", [
-    factory24.createTypeReferenceNode("R"),
-    factory24.createTypeReferenceNode("Args")
-  ]));
-  return {
-    exports: [
-      required_args_type,
-      default_args_type,
-      apply_dispatcher_type,
-      dispatcher_type
-    ],
-    paths: new Set,
-    ...add({ imports })
-  };
-}
 
 // src/typegen/index.ts
 var { factory: factory25 } = ts26;
@@ -2633,6 +2600,7 @@ class TypesGenerator {
   dispatcher_properties = new Map;
   resolved_symbols = new Map;
   resolved_dispatchers = new Map;
+  dispatcher_info = new Map;
   constructor() {}
   resolve_types(symbols, translation_keys) {
     console.log("registries");
@@ -2640,18 +2608,42 @@ class TypesGenerator {
     const registry_exports = export_registry(this.resolved_registries);
     this.resolved_symbols.set("::java::registry", registry_exports);
     const dispatchers = symbols.getVisibleSymbols("mcdoc/dispatcher");
-    for (const id of Object.keys(dispatchers)) {
-      if ("%none" in dispatchers[id].members) {
-        this.dispatcher_properties.set(id, { supports_none: true });
-      }
-    }
+    console.log("dispatcher info");
+    this.precompute_dispatcher_info(dispatchers);
     console.log("modules");
     const module_map = symbols.getVisibleSymbols("mcdoc");
     this.resolve_module_symbols(module_map, symbols);
     console.log("dispatchers");
     this.resolve_dispatcher_symbols(dispatchers, module_map, symbols);
-    const dispatcher_exports = export_dispatcher(this.resolved_dispatchers);
-    this.resolved_symbols.set("mcdoc::dispatcher", dispatcher_exports);
+    const dispatcher_exports = export_dispatchers(dispatcher_symbol_paths);
+    this.resolved_symbols.set("::java::dispatcher", dispatcher_exports);
+  }
+  precompute_dispatcher_info(dispatchers) {
+    for (const id of Object.keys(dispatchers)) {
+      const { members } = dispatchers[id];
+      if (members === undefined) {
+        continue;
+      }
+      if ("%none" in members) {
+        this.dispatcher_properties.set(id, { supports_none: true });
+      }
+      const [namespace, _name] = id.split(":");
+      const name = pascal_case(`${namespace === "mcdoc" ? "mcdoc_" : ""}${_name}`);
+      const symbol_name = `Symbol${name}`;
+      const first_member_key = Object.keys(members).find((k) => !k.startsWith("%"));
+      let generic_count = 0;
+      if (first_member_key) {
+        const first_type = members[first_member_key].data.typeDef;
+        if (first_type.kind === "template") {
+          generic_count = first_type.typeParams.length;
+        }
+      }
+      this.dispatcher_info.set(id, {
+        symbol_name,
+        generic_count,
+        has_fallback_type: "%unknown" in members
+      });
+    }
   }
   resolve_registry_symbols(registries, translation_keys) {
     for (const registry_name of [...AllCategories]) {
@@ -2710,6 +2702,7 @@ class TypesGenerator {
         }
         const resolved_member = get_type_handler(type)(type)({
           dispatcher_properties: this.dispatcher_properties,
+          dispatcher_info: this.dispatcher_info,
           root_type: true,
           name,
           module_path,
@@ -2747,7 +2740,7 @@ class TypesGenerator {
       }
       const [namespace, _name] = id.split(":");
       const name = pascal_case(`${namespace === "mcdoc" ? "mcdoc_" : ""}${_name}`);
-      const { types, imports, references, generic_count } = DispatcherSymbol(id, name, members, this.dispatcher_properties, module_map, symbols);
+      const { types, imports, references, generic_count } = DispatcherSymbol(id, name, members, this.dispatcher_properties, this.dispatcher_info, module_map, symbols);
       let in_module = false;
       const symbol_path = (() => {
         if (namespace === "mcdoc") {
@@ -2762,6 +2755,12 @@ class TypesGenerator {
         }
         return `::java::_dispatcher::${_name}`;
       })();
+      const info = this.dispatcher_info.get(id);
+      dispatcher_symbol_paths.set(symbol_path, {
+        symbol_name: `Symbol${name}`,
+        base_name: name,
+        has_fallback_type: info.has_fallback_type
+      });
       const dispatcher_type_name = `Symbol${name}`;
       this.resolved_dispatchers.set(id, {
         import_path: `${symbol_path}::${dispatcher_type_name}`,
@@ -2772,18 +2771,35 @@ class TypesGenerator {
       if (in_module && this.resolved_symbols.has(symbol_path)) {
         const mod = this.resolved_symbols.get(symbol_path);
         mod.exports.push(...types);
+        let module_has_imports = false;
+        if (mod.imports !== undefined) {
+          module_has_imports = true;
+        }
         if (imports !== undefined) {
-          for (const path of imports.ordered) {
-            if (!mod.paths.has(path)) {
-              mod.imports = add_import(mod.imports, path);
-            }
-          }
+          mod.imports = merge_imports(mod.imports, imports);
+        }
+        if (mod.imports !== undefined) {
+          const same_module_pattern = new RegExp(`^${symbol_path}::[^:]+$`);
+          mod.imports.ordered = mod.imports.ordered.filter((imp) => imp !== `::java::dispatcher::Symbol${name}` && !same_module_pattern.test(imp));
         }
       } else {
+        let filtered_imports = imports;
+        if (imports !== undefined) {
+          const same_module_pattern = new RegExp(`^${symbol_path}::[^:]+$`);
+          const filtered_ordered = imports.ordered.filter((imp) => imp !== `::java::dispatcher::Symbol${name}` && !same_module_pattern.test(imp));
+          if (filtered_ordered.length > 0) {
+            filtered_imports = {
+              ordered: filtered_ordered,
+              check: new Map(filtered_ordered.map((imp, i) => [imp, i]))
+            };
+          } else {
+            filtered_imports = undefined;
+          }
+        }
         this.resolved_symbols.set(symbol_path, {
           exports: types,
           paths: new Set2,
-          ...add({ imports })
+          ...add({ imports: filtered_imports })
         });
       }
     }
@@ -2819,7 +2835,7 @@ var eslint = new ESLint({
         "@stylistic": stylistic
       },
       rules: {
-        "@stylistic/indent": ["error", 4],
+        "@stylistic/indent": ["error", 2],
         "@stylistic/quotes": ["error", "single"],
         "@stylistic/semi": ["error", "never"],
         "@stylistic/member-delimiter-style": ["error", {
@@ -2883,14 +2899,14 @@ function handle_imports(imports) {
     if (path.length === 0) {
       throw new Error(`[mcdoc_import] Import path has no module prefix: "${import_path}"`);
     } else if (path[1] === "java") {
-      file = `sandstone/arguments/generated/${path.slice(2).join("/")}.js`;
+      file = `sandstone/arguments/generated/${path.slice(2).join("/")}.ts`;
     } else if (path[0] === "sandstone") {
       if (path.length === 1) {
         file = "sandstone";
       } else if (path[1] === "arguments" && path.length === 2) {
         file = "sandstone/arguments";
       } else {
-        file = `${path.join("/")}.js`;
+        file = `${path.join("/")}.ts`;
       }
     } else {
       throw new Error(`[mcdoc_import] Unsupported import location "${path[0]}" in "${import_path}"`);
@@ -2922,7 +2938,7 @@ function handle_imports(imports) {
 // src/index.ts
 var writeFile2 = promisify(fs2.writeFile);
 var mkdir2 = promisify(fs2.mkdir);
-var cache_root = join(dirname(fileURLToPath(import.meta.url)), "cache");
+var cache_root = join(process.cwd(), "cache");
 function registerAttributes(meta, release) {
   mcdoc5.runtime.registerAttribute(meta, "since", mcdoc5.runtime.attribute.validator.string, {
     filterElement: () => false

package/dist/typegen/export.d.ts

@@ -1,6 +1,15 @@
 import ts from 'typescript';
 import { type NonEmptyList } from './mcdoc/utils';
-import type { ResolvedDispatcher, ResolvedRegistry } from '.';
+import type { ResolvedRegistry, ResolvedSymbol } from '.';
+/**
+ * Generates named export statements for all dispatcher symbols.
+ * Exports `SymbolName` and optionally `NameFallbackType` when %unknown is present.
+ */
+export declare function export_dispatchers(paths: Map<string, {
+    symbol_name: string;
+    base_name: string;
+    has_fallback_type: boolean;
+}>): ResolvedSymbol;
 export declare function export_registry(resolved_registries: Map<string, ResolvedRegistry>): {
     readonly exports: (ts.TypeAliasDeclaration | ts.VariableStatement)[];
     readonly paths: Set<string>;
@@ -12,28 +21,3 @@ export declare function export_registry(resolved_registries: Map<string, Resolve
     readonly exports: (ts.TypeAliasDeclaration | ts.VariableStatement)[];
     readonly paths: Set<string>;
 };
-/**
- * Generates a `Dispatcher` type system with type-safe generic enforcement.
- *
- * Example output:
- * ```ts
- * interface DispatcherRequiredArgs {
- *   'minecraft:data_component': []
- *   'minecraft:entity_effect': [unknown]
- * }
- * type DefaultArgs<R extends keyof DispatcherRequiredArgs> = ...
- * type ApplyDispatcher<R, Args> = ...
- * export type Dispatcher<R, Args> = ApplyDispatcher<R, Args>
- * ```
- */
-export declare function export_dispatcher(resolved_dispatchers: Map<string, ResolvedDispatcher>): {
-    readonly exports: ts.TypeAliasDeclaration[];
-    readonly paths: Set<string>;
-} | {
-    readonly imports: {
-        readonly ordered: NonEmptyList<string>;
-        readonly check: Map<string, number>;
-    };
-    readonly exports: ts.TypeAliasDeclaration[];
-    readonly paths: Set<string>;
-};

package/dist/typegen/index.d.ts

@@ -23,6 +23,18 @@ export type ResolvedDispatcher = {
      */
     symbol_name: string;
 };
+/**
+ * Pre-computed dispatcher info for use during type resolution.
+ * Maps dispatcher ID (e.g., 'minecraft:entity_effect') to symbol info.
+ */
+export type DispatcherInfo = {
+    /** The symbol type name (e.g., "SymbolEntityEffect") */
+    symbol_name: string;
+    /** Number of generic parameters (excluding CASE) */
+    generic_count: number;
+    /** Whether this dispatcher has a %unknown member (exports FallbackType) */
+    has_fallback_type: boolean;
+};
 export declare class TypesGenerator {
     readonly resolved_registries: Map<string, ResolvedRegistry>;
     readonly dispatcher_properties: Map<string, {
@@ -30,8 +42,19 @@ export declare class TypesGenerator {
     }>;
     readonly resolved_symbols: Map<string, ResolvedSymbol>;
     readonly resolved_dispatchers: Map<string, ResolvedDispatcher>;
+    /** Pre-computed dispatcher info for use during type resolution */
+    readonly dispatcher_info: Map<string, DispatcherInfo>;
     constructor();
     resolve_types(symbols: SymbolUtil, translation_keys: string[]): void;
+    /**
+     * Pre-computes dispatcher info (symbol names and import paths) before module resolution.
+     * This allows modules to directly reference SymbolX types instead of the central Dispatcher type.
+     *
+     * Also populates dispatcher_properties with supports_none info.
+     *
+     * Note: All dispatchers are placed in _dispatcher/ (or _builtin/ for mcdoc namespace) for predictability.
+     */
+    private precompute_dispatcher_info;
     private resolve_registry_symbols;
     private resolve_module_symbols;
     private resolve_dispatcher_symbols;

package/dist/typegen/mcdoc/complex/dispatcher.d.ts

@@ -8,11 +8,11 @@ import type { NonEmptyList } from '..';
  * - `registry`: The dispatcher identifier (e.g., `minecraft:entity_effect`)
  * - `parallelIndices`: How to look up into the dispatcher (static or dynamic)
  *
- * The generated type references the central Dispatcher type:
- * - Static index: `Dispatcher<'minecraft:entity_effect'>['specific_key']`
- * - Dynamic index: `Dispatcher<'minecraft:entity_effect'>[Key]`
- * - Fallback: `Dispatcher<'minecraft:entity_effect', ['%fallback']>`
- * - None: `Dispatcher<'minecraft:entity_effect', ['%none']>`
+ * The generated type directly references the Symbol type:
+ * - Static index: `SymbolEntityEffect['specific_key']`
+ * - Dynamic index: `SymbolEntityEffect[Key]`
+ * - Fallback: `SymbolEntityEffect<'%fallback'>`
+ * - None: `SymbolEntityEffect<'%none'>`
  */
 declare function mcdoc_dispatcher(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
     readonly type: ts.TypeNode;

package/dist/typegen/mcdoc/dispatcher_symbol.d.ts

@@ -1,6 +1,7 @@
 import ts from 'typescript';
 import type { SymbolMap, SymbolUtil } from '@spyglassmc/core';
 import { type NonEmptyList } from '.';
+import type { DispatcherInfo } from '..';
 export type DispatcherReferenceCounter = {
     /**
      * Map<path: string, location_counts_index: number>
@@ -9,6 +10,19 @@ export type DispatcherReferenceCounter = {
     location_counts: [path: string, count: number][];
 };
 export declare const dispatcher_references: Map<string, DispatcherReferenceCounter>;
+export type DispatcherExportInfo = {
+    /** The symbol name without the path (e.g., "SymbolEntityEffect") */
+    symbol_name: string;
+    /** The base name without Symbol prefix (e.g., "EntityEffect") */
+    base_name: string;
+    /** Whether this dispatcher exports a FallbackType */
+    has_fallback_type: boolean;
+};
+/**
+ * Global map of dispatcher symbol paths to their export info.
+ * Populated during `resolve_dispatcher_symbols`.
+ */
+export declare const dispatcher_symbol_paths: Map<string, DispatcherExportInfo>;
 type DispatcherSymbolResult = {
     /**
      * The main exported type `SymbolName<CASE>` and all supporting type aliases (member types, map, keys, fallback, unknown)
@@ -53,6 +67,6 @@ type DispatcherSymbolResult = {
  */
 export declare function dispatcher_symbol(id: string, name: string, members: SymbolMap, dispatcher_properties: Map<string, {
     supports_none?: true;
-}>, module_map: SymbolMap, symbols: SymbolUtil): DispatcherSymbolResult;
+}>, dispatcher_info: Map<string, DispatcherInfo>, module_map: SymbolMap, symbols: SymbolUtil): DispatcherSymbolResult;
 export declare const DispatcherSymbol: typeof dispatcher_symbol;
 export {};

package/dist/typegen/mcdoc/utils.d.ts

@@ -11,7 +11,7 @@ export type NonEmptyList<T> = T[] & {
  */
 export declare function is_valid_registry(symbols: SymbolUtil | undefined, registry_id: string): boolean;
 export declare function add_import(imports: TypeHandlerResult['imports'], add_import: string): NonNullable<TypeHandlerResult['imports']>;
-export declare function merge_imports(imports: TypeHandlerResult['imports'], new_imports: NonNullable<TypeHandlerResult['imports']>): NonNullable<TypeHandlerResult['imports']>;
+export declare function merge_imports(imports: TypeHandlerResult['imports'], new_imports: NonNullable<TypeHandlerResult['imports']>, filter?: Set<string>): NonNullable<TypeHandlerResult['imports']>;
 type GetConstructorArgs<T> = T extends new (...args: infer U) => any ? U : never;
 export declare class Set<T> extends global.Set<T> {
     constructor(...args: GetConstructorArgs<typeof global.Set<T>>);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sandstone-mc/mcdoc-ts-generator",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Generate TypeScript types from Minecraft mcdoc definitions",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,7 +19,8 @@
     "dist"
   ],
   "scripts": {
-    "compile": "bun run ./src/cli.ts",
+    "compile": "rm -rf types/ && bun run ./src/cli.ts",
+    "typecheck": "bun tsc --emitDeclarationOnly false --noEmit",
     "build": "bun run build:bundle && bun run build:types",
     "build:bundle": "bun build ./src/cli.ts --outfile ./dist/cli.js --target node --format esm --packages external && bun build ./src/index.ts --outfile ./dist/index.js --target node --format esm --packages external",
     "build:types": "bun tsc --emitDeclarationOnly --declaration --outDir ./dist",