@sandstone-mc/mcdoc-ts-generator 0.1.0

package/dist/index.js

@@ -0,0 +1,3086 @@
+// src/index.ts
+import { dirname, resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import {
+  ConfigService,
+  fileUtil,
+  Service,
+  VanillaConfig
+} from "@spyglassmc/core";
+import { NodeJsExternals } from "@spyglassmc/core/lib/nodejs.js";
+import * as je from "@spyglassmc/java-edition";
+import { ReleaseVersion } from "@spyglassmc/java-edition/lib/dependency/index.js";
+import * as mcdoc5 from "@spyglassmc/mcdoc";
+
+// src/util/index.ts
+function errorMessage(e) {
+  if (e instanceof Error)
+    return e.message;
+  return `${e}`;
+}
+var join = (...paths) => paths.join("/");
+function pascal_case(name) {
+  const words = name.split(/\/|_/);
+  return words.map((word) => word[0].toUpperCase() + word.slice(1)).join("");
+}
+function pluralize(name) {
+  if (name.endsWith("y"))
+    return name.slice(0, -1) + "ies";
+  if (name.endsWith("s") || name.endsWith("ch") || name.endsWith("sh") || name.endsWith("x") || name.endsWith("z"))
+    return name + "es";
+  return name + "s";
+}
+function add(obj) {
+  const filtered = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== undefined) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+
+// src/util/fetch.ts
+import fs from "fs";
+import fsp from "fs/promises";
+import stream from "stream";
+import os from "os";
+import { join as join2 } from "node:path";
+class HttpCache {
+  #cacheRoot;
+  constructor(cacheRoot) {
+    if (cacheRoot) {
+      this.#cacheRoot = `${cacheRoot}http/`;
+    }
+  }
+  async match(request, _options) {
+    if (!this.#cacheRoot) {
+      return;
+    }
+    const fileName = this.#getFileName(request);
+    try {
+      const etag = (await fsp.readFile(join2(this.#cacheRoot, `${fileName}.etag`), "utf8")).trim();
+      const bodyStream = fs.createReadStream(join2(this.#cacheRoot, `${fileName}.bin`));
+      return new Response(stream.Readable.toWeb(bodyStream), { headers: { etag } });
+    } catch (e) {
+      if (e?.code === "ENOENT") {
+        return;
+      }
+      throw e;
+    }
+  }
+  async put(request, response) {
+    const clonedResponse = response.clone();
+    const etag = clonedResponse.headers.get("etag");
+    if (!(this.#cacheRoot && clonedResponse.body && etag)) {
+      return;
+    }
+    const fileName = this.#getFileName(request);
+    await fsp.mkdir(this.#cacheRoot, { recursive: true });
+    await Promise.all([
+      fsp.writeFile(join2(this.#cacheRoot, `${fileName}.bin`), stream.Readable.fromWeb(clonedResponse.body)),
+      fsp.writeFile(join2(this.#cacheRoot, `${fileName}.etag`), `${etag}${os.EOL}`)
+    ]);
+  }
+  #getFileName(request) {
+    const uriString = request instanceof Request ? request.url : request.toString();
+    return Buffer.from(uriString, "utf8").toString("base64url");
+  }
+  async add() {
+    throw new Error("Method not implemented.");
+  }
+  async addAll() {
+    throw new Error("Method not implemented.");
+  }
+  async delete() {
+    throw new Error("Method not implemented.");
+  }
+  async keys() {
+    throw new Error("Method not implemented.");
+  }
+  async matchAll() {
+    throw new Error("Method not implemented.");
+  }
+}
+var cache = new HttpCache("./cache");
+async function fetchWithCache(input, init) {
+  const request = new Request(input, init);
+  const cachedResponse = await cache.match(request);
+  const cachedEtag = cachedResponse?.headers.get("ETag");
+  if (cachedEtag) {
+    request.headers.set("If-None-Match", cachedEtag);
+  }
+  try {
+    const response = await fetch(request);
+    if (response.status === 304) {
+      console.info(`[fetchWithCache] reusing cache for ${request.url}`);
+      return cachedResponse;
+    } else {
+      try {
+        await cache.put(request, response);
+        console.info(`[fetchWithCache] updated cache for ${request.url}`);
+      } catch (e) {
+        console.warn("[fetchWithCache] put cache", e);
+      }
+      return response;
+    }
+  } catch (e) {
+    console.warn("[fetchWithCache] fetch", e);
+    if (cachedResponse) {
+      console.info(`[fetchWithCache] falling back to cache for ${request.url}`);
+      return cachedResponse;
+    }
+    throw e;
+  }
+}
+
+// src/typegen/index.ts
+import { AllCategories } from "@spyglassmc/core";
+import ts26 from "typescript";
+
+// src/typegen/mcdoc/list/list.ts
+import ts3 from "typescript";
+import * as mcdoc2 from "@spyglassmc/mcdoc";
+
+// src/typegen/mcdoc/utils.ts
+function is_valid_registry(symbols, registry_id) {
+  if (symbols === undefined) {
+    return true;
+  }
+  const registry_name = registry_id.replace(/^minecraft:/, "");
+  const registry = symbols.getVisibleSymbols(registry_name);
+  return Object.keys(registry).length > 0;
+}
+function add_import(imports, add_import2) {
+  if (imports === undefined) {
+    return {
+      ordered: [add_import2],
+      check: new Map([[add_import2, 0]])
+    };
+  }
+  if (imports.check.has(add_import2)) {
+    return imports;
+  }
+  if (imports.ordered.length === 1) {
+    const existing_import = imports.ordered[0];
+    if (add_import2.localeCompare(existing_import) < 0) {
+      imports.ordered.unshift(add_import2);
+      imports.check.set(add_import2, 0);
+      imports.check.set(existing_import, 1);
+    } else {
+      imports.ordered.push(add_import2);
+      imports.check.set(add_import2, 1);
+    }
+    return imports;
+  }
+  let left = 0;
+  let right = imports.ordered.length;
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+    const mid_path = imports.ordered[mid];
+    if (add_import2.localeCompare(mid_path) < 0) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+  imports.ordered.splice(left, 0, add_import2);
+  imports.check.set(add_import2, left);
+  for (let i = left + 1;i < imports.ordered.length; i++) {
+    imports.check.set(imports.ordered[i], i);
+  }
+  return imports;
+}
+function merge_imports(imports, new_imports) {
+  if (imports === undefined) {
+    return new_imports;
+  }
+  for (const import_path of new_imports.ordered) {
+    if (!imports.check.has(import_path)) {
+      imports = add_import(imports, import_path);
+    }
+  }
+  return imports;
+}
+
+class Set2 extends global.Set {
+  constructor(...args) {
+    super(...args);
+  }
+  has(value) {
+    return super.has(value);
+  }
+}
+
+// src/typegen/mcdoc/assert.ts
+import { match, P } from "ts-pattern";
+
+class AssertKinds {
+  static AttributeRootValueKind = new Set2(["dispatcher", "reference", "literal", "tree"]);
+  static AttributeTreeChildKind = new Set2(["reference", "literal", "tree"]);
+  static ImplementedAttributes = new Set2([
+    "id",
+    "since",
+    "until",
+    "permutation",
+    "texture_slot",
+    "item_slots",
+    "tag",
+    "team",
+    "translation_key",
+    "translation_value",
+    "crafting_ingredient",
+    "block_predicate",
+    "game_rule",
+    "objective",
+    "dispatcher_key",
+    "regex_pattern",
+    "canonical",
+    "color",
+    "time_pattern",
+    "criterion",
+    "nbt",
+    "nbt_path",
+    "match_regex",
+    "deprecated",
+    "command",
+    "url",
+    "uuid",
+    "random",
+    "divisible_by",
+    "entity",
+    "integer",
+    "score_holder",
+    "vector",
+    "bitfield",
+    "text_component"
+  ]);
+  static RegistryAttributeArgument = new Set2(["registry", "path", "definition", "exclude", "tags", "empty", "prefix"]);
+  static RegistryAttributeTagsArgument = new Set2(["allowed", "implicit", "required"]);
+  static ColorAttributeKind = new Set2(["composite_rgb", "composite_argb", "hex_rgb", "hex_argb", "dec_rgb", "dec_rgba", "particle", "named"]);
+  static CommandAttributeArgument = new Set2(["macro", "slash", "incomplete", "empty", "max_length"]);
+  static CommandAttributeSlashKind = new Set2(["allowed", "required", "chat", "none"]);
+  static TextureSlotAttributeKind = new Set2(["definition", "value", "reference"]);
+  static ArrayKind = new Set2(["byte_array", "int_array", "long_array"]);
+  static StructKeyKind = new Set2(["reference", "concrete", "string", "union"]);
+  static StructSpreadKind = new Set2(["reference", "dispatcher", "concrete", "template", "struct", "union"]);
+  static NumericKind = new Set2(["byte", "double", "float", "int", "long", "short"]);
+}
+
+class Assert {
+  static Attributes(type, implemented) {
+    if (type !== undefined) {
+      for (const attribute of type) {
+        if (attribute.value !== undefined && !AssertKinds.AttributeRootValueKind.has(attribute.value.kind)) {
+          throw new Error(`[mcdoc_assert] Attribute Type value is an unsupported kind ${attribute}`);
+        }
+        if (implemented) {
+          if (!AssertKinds.ImplementedAttributes.has(attribute.name)) {
+            throw new Error(`[mcdoc_assert] Attribute Type is unsupported ${attribute.name}`);
+          }
+          const attribute_type = attribute.name;
+          match(attribute_type).with("since", "until", "deprecated", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] Versioned attribute '${attribute_type}' must have a value`);
+            }
+            if (attribute.value.kind !== "literal" || attribute.value.value.kind !== "string" || !/^\d+\.\d+(?:\.\d+)?$/.test(attribute.value.value.value)) {
+              throw new Error(`[mcdoc_assert] Versioned Attribute Type value is invalid ${attribute.value}`);
+            }
+          }).with("id", () => {
+            if (attribute.value !== undefined) {
+              match(attribute.value).with({ kind: "literal", value: { kind: "string", value: P.string } }, () => {}).with({ kind: "tree", values: { registry: { kind: "literal", value: { kind: "string", value: P.string } } } }, (tree) => {
+                const invalid_argument = Object.keys(tree.values).find((argument) => !AssertKinds.RegistryAttributeArgument.has(argument));
+                if (invalid_argument !== undefined) {
+                  throw new Error(`[mcdoc_assert] Invalid Registry Attribute Type argument ${invalid_argument}`);
+                }
+                const args = tree.values;
+                if (args.exclude !== undefined) {
+                  if (args.exclude.kind === "tree") {
+                    if ("0" in args.exclude.values) {
+                      Object.values(args.exclude.values).forEach((exclusion) => {
+                        if (exclusion.kind !== "literal" || exclusion.value.kind !== "string") {
+                          throw new Error(`[mcdoc_assert] Invalid Registry Attribute Type exclusion ${args.exclude}`);
+                        }
+                      });
+                    } else {
+                      throw new Error(`[mcdoc_assert] Invalid Registry Attribute Type exclusion ${args.exclude}`);
+                    }
+                  } else {
+                    throw new Error(`[mcdoc_assert] Invalid Registry Attribute Type exclusion ${args.exclude}`);
+                  }
+                }
+                if (args.empty !== undefined) {
+                  if (args.empty.kind !== "literal" || args.empty.value.value !== "allowed") {
+                    throw new Error(`[mcdoc_assert] Invalid Registry Attribute Type empty argument ${args.empty}`);
+                  }
+                }
+                if (args.definition !== undefined) {
+                  if (args.definition.kind !== "literal" || args.definition?.value.value !== true) {
+                    throw new Error(`[mcdoc_assert] Invalid Definition Registry Attribute Type ${args.empty}`);
+                  }
+                }
+                if (args.path !== undefined) {
+                  if (args.path.kind !== "literal" || !`${args.path.value.value}`.endsWith("/")) {
+                    throw new Error(`[mcdoc_assert] Invalid Pathed Registry Attribute Type ${args.path}`);
+                  }
+                }
+                if (args.prefix !== undefined) {
+                  if (args.prefix.kind !== "literal" || args.prefix.value.value !== "!") {
+                    throw new Error(`[mcdoc_assert] Invalid Registry Attribute Type prefix ${args.prefix}`);
+                  }
+                }
+                if (args.tags !== undefined) {
+                  if (args.tags.kind !== "literal" || !AssertKinds.RegistryAttributeTagsArgument.has(args.tags.value.value)) {
+                    throw new Error(`[mcdoc_assert] Invalid Tag Registry Attribute Type ${args.tags}`);
+                  }
+                }
+              }).otherwise(() => {
+                throw new Error(`[mcdoc_assert] Invalid #[id] attribute value format: expected literal string or tree with registry, got kind '${attribute.value?.kind}'`);
+              });
+            }
+          }).with("bitfield", () => {
+            if (attribute.value === undefined || attribute.value.kind !== "reference" || attribute.value.path === undefined) {
+              throw new Error(`[mcdoc_assert] #[bitfield] attribute must have a reference value with a defined path, got: ${JSON.stringify(attribute.value)}`);
+            }
+          }).with("color", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[color] attribute must have a value`);
+            }
+            if (attribute.value.kind !== "literal" || attribute.value.value.kind !== "string") {
+              throw new Error(`[mcdoc_assert] #[color] attribute value must be a string literal, got kind '${attribute.value.kind}'`);
+            }
+            if (!AssertKinds.ColorAttributeKind.has(attribute.value.value.value)) {
+              throw new Error(`[mcdoc_assert] #[color] attribute has invalid color kind '${attribute.value.value.value}', expected one of: ${[...AssertKinds.ColorAttributeKind].join(", ")}`);
+            }
+          }).with("command", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[command] attribute must have a value`);
+            }
+            if (attribute.value.kind === "tree") {
+              const invalid_argument = Object.keys(attribute.value.values).find((argument) => !AssertKinds.CommandAttributeArgument.has(argument));
+              if (invalid_argument) {
+                throw new Error(`[mcdoc_assert] #[command] attribute has invalid argument '${invalid_argument}', expected one of: ${[...AssertKinds.CommandAttributeArgument].join(", ")}`);
+              }
+              if ("macro" in attribute.value.values && !("slash" in attribute.value.values)) {
+                if (attribute.value.values.macro.kind === "literal") {
+                  if (attribute.value.values.macro.value.value !== "implicit" && attribute.value.values.macro.value.value !== "allowed") {
+                    throw new Error(`[mcdoc_assert] #[command(macro)] value must be 'implicit' or 'allowed', got '${attribute.value.values.macro.value.value}'`);
+                  }
+                } else {
+                  throw new Error(`[mcdoc_assert] #[command(macro)] must be a literal, got kind '${attribute.value.values.macro.kind}'`);
+                }
+              } else if ("slash" in attribute.value.values) {
+                if (attribute.value.values.slash.kind === "literal") {
+                  if (!AssertKinds.CommandAttributeSlashKind.has(attribute.value.values.slash.value.value)) {
+                    throw new Error(`[mcdoc_assert] #[command(slash)] value must be one of: ${[...AssertKinds.CommandAttributeSlashKind].join(", ")}, got '${attribute.value.values.slash.value.value}'`);
+                  }
+                } else {
+                  throw new Error(`[mcdoc_assert] #[command(slash)] must be a literal, got kind '${attribute.value.values.slash.kind}'`);
+                }
+              } else {
+                throw new Error(`[mcdoc_assert] #[command] attribute must have either 'macro' or 'slash' argument`);
+              }
+              if ("empty" in attribute.value.values) {
+                if (attribute.value.values.empty.kind === "literal") {
+                  if (attribute.value.values.empty.value.value !== "allowed") {
+                    throw new Error(`[mcdoc_assert] #[command(empty)] value must be 'allowed', got '${attribute.value.values.empty.value.value}'`);
+                  }
+                } else {
+                  throw new Error(`[mcdoc_assert] #[command(empty)] must be a literal, got kind '${attribute.value.values.empty.kind}'`);
+                }
+              }
+              if ("max_length" in attribute.value.values) {
+                if (attribute.value.values.max_length.kind === "literal") {
+                  if (attribute.value.values.max_length.value.kind !== "int" || attribute.value.values.max_length.value.value < 4) {
+                    throw new Error(`[mcdoc_assert] #[command(max_length)] value must be an integer >= 4, got '${attribute.value.values.max_length.value.value}'`);
+                  }
+                } else {
+                  throw new Error(`[mcdoc_assert] #[command(max_length)] must be a literal, got kind '${attribute.value.values.max_length.kind}'`);
+                }
+              }
+              if ("incomplete" in attribute.value.values) {
+                if (attribute.value.values.incomplete.kind === "literal") {
+                  if (attribute.value.values.incomplete.value.value !== "allowed") {
+                    throw new Error(`[mcdoc_assert] #[command(incomplete)] value must be 'allowed', got '${attribute.value.values.incomplete.value.value}'`);
+                  }
+                } else {
+                  throw new Error(`[mcdoc_assert] #[command(incomplete)] must be a literal, got kind '${attribute.value.values.incomplete.kind}'`);
+                }
+              }
+            } else {
+              throw new Error(`[mcdoc_assert] #[command] attribute value must be a tree, got kind '${attribute.value.kind}'`);
+            }
+          }).with("criterion", "crafting_ingredient", () => {
+            if (attribute.value !== undefined) {
+              if (attribute.value.kind !== "tree" || !("definition" in attribute.value.values) || attribute.value.values.definition.kind !== "literal" || attribute.value.values.definition.value.value !== true) {
+                throw new Error(`[mcdoc_assert] #[${attribute_type}] attribute value must be a tree with 'definition: true', got: ${JSON.stringify(attribute.value)}`);
+              }
+              if (Object.keys(attribute.value.values).length > 1) {
+                throw new Error(`[mcdoc_assert] #[${attribute_type}] attribute tree has unexpected extra arguments: ${Object.keys(attribute.value.values).filter((k) => k !== "definition").join(", ")}`);
+              }
+            }
+          }).with("dispatcher_key", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[dispatcher_key] attribute must have a value`);
+            }
+            if (attribute.value.kind !== "literal" || !/^[\w_]+:[\w_]+$/.test(`${attribute.value.value.value}`)) {
+              throw new Error(`[mcdoc_assert] #[dispatcher_key] attribute value must be a namespaced ID (e.g., 'namespace:path'), got '${attribute.value?.kind === "literal" ? attribute.value.value.value : attribute.value.kind}'`);
+            }
+          }).with("divisible_by", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[divisible_by] attribute must have a value`);
+            }
+            if (attribute.value.kind !== "literal" || !Number.isInteger(Number(attribute.value.value.value))) {
+              throw new Error(`[mcdoc_assert] #[divisible_by] attribute value must be an integer literal, got: ${JSON.stringify(attribute.value)}`);
+            }
+          }).with("integer", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[integer] attribute must have a value`);
+            }
+            if (attribute.value.kind !== "tree" || !("min" in attribute.value.values) || attribute.value.values.min.kind !== "literal" || attribute.value.values.min.value.value !== 1) {
+              throw new Error(`[mcdoc_assert] #[integer] attribute value must be a tree with 'min: 1', got: ${JSON.stringify(attribute.value)}`);
+            }
+            if (Object.keys(attribute.value.values).length > 1) {
+              throw new Error(`[mcdoc_assert] #[integer] attribute tree has unexpected extra arguments: ${Object.keys(attribute.value.values).filter((k) => k !== "min").join(", ")}`);
+            }
+          }).with("nbt", () => {
+            if (attribute.value !== undefined && attribute.value.kind !== "dispatcher" && attribute.value.kind !== "reference") {
+              throw new Error(`[mcdoc_assert] #[nbt] attribute value must be a dispatcher or reference, got kind '${attribute.value.kind}'`);
+            }
+            if (attribute.value?.kind === "reference" && attribute.value.path === undefined) {
+              throw new Error(`[mcdoc_assert] #[nbt] attribute reference value must have a defined path`);
+            }
+          }).with("nbt_path", () => {
+            if (attribute.value !== undefined && attribute.value.kind !== "dispatcher") {
+              throw new Error(`[mcdoc_assert] #[nbt_path] attribute value must be a dispatcher, got kind '${attribute.value.kind}'`);
+            }
+          }).with("match_regex", () => {
+            if (attribute.value === undefined || attribute.value.kind !== "literal" || attribute.value.value.kind !== "string") {
+              throw new Error(`[mcdoc_assert] #[match_regex] attribute value must be a string literal, got: ${JSON.stringify(attribute.value)}`);
+            } else {
+              try {
+                new RegExp(attribute.value.value.value);
+              } catch (e) {
+                throw new Error(`[mcdoc_assert] #[match_regex] attribute contains invalid regex pattern '${attribute.value.value.value}': ${e}`);
+              }
+            }
+          }).with("permutation", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[permutation] attribute must have a value`);
+            }
+            if (!(attribute.value.kind === "tree" && ("definition" in attribute.value.values) && attribute.value.values.definition.kind === "literal" && attribute.value.values.definition.value.value === true)) {
+              throw new Error(`[mcdoc_assert] #[permutation] attribute value must be a tree with 'definition: true', got: ${JSON.stringify(attribute.value)}`);
+            }
+            if (Object.keys(attribute.value.values).length > 1) {
+              throw new Error(`[mcdoc_assert] #[permutation] attribute tree has unexpected extra arguments: ${Object.keys(attribute.value.values).filter((k) => k !== "definition").join(", ")}`);
+            }
+          }).with("entity", (entity) => {
+            if (attribute.value !== undefined) {
+              if (attribute.value.kind !== "tree") {
+                throw new Error(`[mcdoc_assert] #[entity] attribute value must contain arguments, received a ${attribute.value.kind}`);
+              }
+              const keys = new Set2(Object.keys(attribute.value.values));
+              if ("amount" in attribute.value.values) {
+                keys.delete("amount");
+                if (attribute.value.values.amount.kind !== "literal" || attribute.value.values.amount.value.kind !== "string") {
+                  throw new Error(`[mcdoc_assert] #[entity(amount)] has unsupported value: ${JSON.stringify(attribute.value.values.amount)}`);
+                }
+                if (attribute.value.values.amount.value.value !== "multiple" && attribute.value.values.amount.value.value !== "single") {
+                  throw new Error(`[mcdoc_assert] #[entity(amount="${attribute.value.values.amount.value.value}")] is unsupported`);
+                }
+              }
+              if ("type" in attribute.value.values) {
+                keys.delete("type");
+                if (attribute.value.values.type.kind !== "literal" || attribute.value.values.type.value.kind !== "string") {
+                  throw new Error(`[mcdoc_assert] #[entity(type)] has unsupported value: ${JSON.stringify(attribute.value.values.type)}`);
+                }
+                if (attribute.value.values.type.value.value !== "entities" && attribute.value.values.type.value.value !== "players") {
+                  throw new Error(`[mcdoc_assert] #[entity(type="${attribute.value.values.type.value.value}")] is unsupported`);
+                }
+              }
+              if (keys.size > 0) {
+                throw new Error(`[mcdoc_assert] Unsupported #[entity] attribute arguments: ${[...keys.values()].join(", ")}`);
+              }
+            }
+          }).with("random", "regex_pattern", "time_pattern", "canonical", "text_component", "score_holder", "objective", "translation_key", "translation_value", "item_slots", "uuid", "url", "team", "game_rule", "tag", "block_predicate", (a) => {
+            if (a !== "translation_key" && a !== "game_rule" && attribute.value !== undefined) {
+              console.log(attribute);
+              throw new Error(`[mcdoc_assert] Unexpected value on attribute '${a}'`);
+            }
+          }).with("texture_slot", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[texture_slot] attribute must have a value`);
+            }
+            if (attribute.value.kind !== "tree" || !("kind" in attribute.value.values) || attribute.value.values.kind.kind !== "literal" || !AssertKinds.TextureSlotAttributeKind.has(attribute.value.values.kind.value.value)) {
+              throw new Error(`[mcdoc_assert] #[texture_slot] attribute value must be a tree with a valid 'kind' (one of: ${[...AssertKinds.TextureSlotAttributeKind].join(", ")}), got: ${JSON.stringify(attribute.value)}`);
+            }
+            if (Object.keys(attribute.value.values).length > 1) {
+              throw new Error(`[mcdoc_assert] #[texture_slot] attribute tree has unexpected extra arguments: ${Object.keys(attribute.value.values).filter((k) => k !== "kind").join(", ")}`);
+            }
+          }).with("vector", () => {
+            if (attribute.value === undefined) {
+              throw new Error(`[mcdoc_assert] #[vector] attribute must have a value`);
+            }
+            if (attribute.value.kind !== "tree" || !("dimension" in attribute.value.values) || !("integer" in attribute.value.values)) {
+              throw new Error(`[mcdoc_assert] #[vector] attribute value must be a tree with 'dimension' and 'integer' arguments, got: ${JSON.stringify(attribute.value)}`);
+            }
+            if (attribute.value.values.dimension.kind !== "literal" || attribute.value.values.dimension.value.value !== 3) {
+              throw new Error(`[mcdoc_assert] #[vector(dimension)] must be 3, got: ${JSON.stringify(attribute.value.values.dimension)}`);
+            }
+            if (attribute.value.values.integer.kind !== "literal" || attribute.value.values.integer.value.value !== true) {
+              throw new Error(`[mcdoc_assert] #[vector(integer)] must be true, got: ${JSON.stringify(attribute.value.values.integer)}`);
+            }
+            if (Object.keys(attribute.value.values).length > 2) {
+              throw new Error(`[mcdoc_assert] #[vector] attribute tree has unexpected extra arguments: ${Object.keys(attribute.value.values).filter((k) => k !== "dimension" && k !== "integer").join(", ")}`);
+            }
+          }).exhaustive();
+        } else if (attribute.value !== undefined) {
+          switch (attribute.value.kind) {
+            case "literal":
+              {
+                if (attribute.value.value.kind !== "string") {
+                  throw new Error(`[mcdoc_assert] Literal Attribute Type value type is an unsupported kind ${attribute}`);
+                }
+              }
+              break;
+            case "reference":
+              {
+                if (attribute.value.path === undefined) {
+                  throw new Error(`[mcdoc_assert] Reference Attribute Type value type must have a defined path ${attribute}`);
+                }
+              }
+              break;
+            case "tree":
+              {
+                for (const [key, value] of Object.entries(attribute.value.values)) {
+                  if (!Number.isNaN(Number(key.charAt(0)))) {
+                    throw new Error(`[mcdoc_assert] Root Tree Attribute Type value type is an array, this is unsupported ${attribute}`);
+                  }
+                  if (!AssertKinds.AttributeTreeChildKind.has(value.kind)) {
+                    throw new Error(`[mcdoc_assert] Root Tree Attribute Type value value is an unsupported kind ${attribute}`);
+                  }
+                  switch (value.kind) {
+                    case "literal":
+                      {
+                        if (value.value.kind !== "boolean" && value.value.kind !== "string") {
+                          throw new Error(`[mcdoc_assert] Numerical Literal Root Tree Attribute Type value value type is unsupported ${attribute}`);
+                        }
+                      }
+                      break;
+                    case "tree": {
+                      if (!("0" in value.values)) {
+                        throw new Error(`[mcdoc_assert] Nested Named Tree Attribute value type is unsupported ${attribute}`);
+                      }
+                      for (const member of Object.values(value.values)) {
+                        if (member.kind !== "literal" || member.value.kind !== "string") {
+                          throw new Error(`[mcdoc_assert] Array Attribute Type value type is not string, this is unsupported ${attribute}`);
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              break;
+          }
+        }
+      }
+    }
+  }
+  static DispatcherType(type) {
+    if (type.kind !== "dispatcher") {}
+  }
+  static IndexedType(type) {
+    if (type.kind !== "indexed") {
+      throw new Error(`[mcdoc_assert] Type is not an IndexedType: ${type.kind}`);
+    }
+  }
+  static TemplateType(type) {
+    if (type.kind !== "template") {
+      throw new Error(`[mcdoc_assert] Type is not a TemplateType: ${type.kind}`);
+    }
+  }
+  static ArrayType(type) {
+    if (!AssertKinds.ArrayKind.has(type.kind)) {
+      throw new Error(`[mcdoc_assert] Type is not a PrimitiveArrayType: ${type.kind}`);
+    }
+  }
+  static ListType(type) {
+    if (type.kind !== "list") {
+      throw new Error(`[mcdoc_assert] Type is not a ListType: ${type.kind}`);
+    }
+  }
+  static EnumType(type) {
+    if (type.kind !== "enum") {
+      throw new Error(`[mcdoc_assert] Type is not an EnumType: ${type.kind}`);
+    }
+  }
+  static StructType(type) {
+    if (type.kind !== "struct") {
+      throw new Error(`[mcdoc_assert] Type is not a StructType: ${type.kind}`);
+    }
+  }
+  static StructKeyType(type) {
+    if (!AssertKinds.StructKeyKind.has(type.kind)) {
+      throw new Error(`[mcdoc_assert] Struct field key must be a ReferenceType or StringType, got: ${type.kind}`);
+    }
+    if (type.kind === "concrete" && (type.child.kind !== "reference" || type.child.path === undefined)) {
+      throw new Error(`[mcdoc_assert] Struct field key ConcreteType must wrap a ReferenceType with a defined path. ${type}`);
+    }
+    if (type.kind === "reference" && type.path === undefined) {
+      throw new Error(`[mcdoc_assert] Struct field key ReferenceType must have a path defined. ${type}`);
+    }
+  }
+  static StructSpreadType(type) {
+    if (!AssertKinds.StructSpreadKind.has(type.kind)) {
+      throw new Error(`[mcdoc_assert] Struct spread type must be a reference-alike, got: ${type.kind}`);
+    }
+    if (type.kind === "reference" && type.path === undefined) {
+      throw new Error(`[mcdoc_assert] Struct spread ReferenceType must have a path defined. ${type}`);
+    }
+  }
+  static TupleType(type) {
+    if (type.kind !== "tuple") {
+      throw new Error(`[mcdoc_assert] Type is not a TupleType: ${type.kind}`);
+    }
+  }
+  static UnionType(type) {
+    if (type.kind !== "union") {
+      throw new Error(`[mcdoc_assert] Type is not a UnionType: ${type.kind}`);
+    }
+  }
+  static KeywordType(type) {
+    if (type.kind !== "any" && type.kind !== "boolean" && type.kind !== "unsafe") {
+      throw new Error(`[mcdoc_assert] Type is not a KeywordType: ${type.kind}`);
+    }
+  }
+  static NumericType(type) {
+    if (!AssertKinds.NumericKind.has(type.kind)) {
+      throw new Error(`[mcdoc_assert] Type is not a NumericType: ${type.kind}`);
+    }
+  }
+  static ConcreteType(type) {
+    if (type.kind !== "concrete") {
+      throw new Error(`[mcdoc_assert] Type is not a ConcreteType: ${type.kind}`);
+    }
+    if (type.child.kind === "reference") {
+      if (type.child.path === undefined) {
+        throw new Error(`[mcdoc_assert] ConcreteType child type of ReferenceType is missing a path: ${type}`);
+      }
+    } else if (type.child.kind !== "dispatcher") {
+      throw new Error(`[mcdoc_assert] Concrete child type is invalid: ${type}`);
+    }
+  }
+  static LiteralType(type) {
+    if (type.kind !== "literal") {
+      throw new Error(`[mcdoc_assert] Type is not a LiteralType: ${type.kind}`);
+    }
+  }
+  static ReferenceType(type) {
+    if (type.kind !== "reference" || type.path === undefined) {
+      throw new Error(`[mcdoc_assert] Type is not a valid ReferenceType: ${type}`);
+    }
+  }
+  static StringType(type) {
+    if (type.kind !== "string") {
+      throw new Error(`[mcdoc_assert] Type is not a StringType: ${type.kind}`);
+    }
+  }
+  static ColorStringType(type) {
+    if (type !== "hex_argb" && type !== "hex_rgb") {
+      throw new Error(`[mcdoc_assert] String color type is not valid ${type}`);
+    }
+  }
+}
+
+// src/typegen/mcdoc/bind.ts
+import ts from "typescript";
+var { factory } = ts;
+
+class Bind {
+  static NumericLiteral(literal) {
+    if (Math.sign(literal) === -1) {
+      return factory.createLiteralTypeNode(factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(literal))));
+    } else {
+      return factory.createLiteralTypeNode(factory.createNumericLiteral(literal));
+    }
+  }
+  static StringLiteral(literal) {
+    return factory.createLiteralTypeNode(factory.createStringLiteral(literal, true));
+  }
+  static NonEmptyString = factory.createTemplateLiteralType(factory.createTemplateHead(""), [
+    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), factory.createTemplateMiddle("")),
+    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), factory.createTemplateTail(""))
+  ]);
+  static Namespaced = factory.createTemplateLiteralType(factory.createTemplateHead(""), [
+    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), factory.createTemplateMiddle(":")),
+    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), factory.createTemplateTail(""))
+  ]);
+  static MappedType(key_type, value_type, options) {
+    const { key_name = "Key", parenthesized = true } = options ?? {};
+    const constraint_type = key_type.kind === ts.SyntaxKind.StringKeyword ? Bind.NonEmptyString : factory.createTypeReferenceNode("Extract", [
+      key_type,
+      factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+    ]);
+    const mapped_type = factory.createMappedTypeNode(undefined, factory.createTypeParameterDeclaration(undefined, key_name, constraint_type), undefined, factory.createToken(ts.SyntaxKind.QuestionToken), value_type, undefined);
+    return parenthesized ? factory.createParenthesizedType(mapped_type) : mapped_type;
+  }
+  static EmptyObject = factory.createTypeReferenceNode("Record", [
+    factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+    factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
+  ]);
+  static DocPart(doc) {
+    return doc.trim().replaceAll(`
+
+
+
+ `, "@@bad@@").replaceAll(`
+
+`, `
+`).replaceAll("@@bad@@", `
+
+`).split(`
+`);
+  }
+  static Doc(node, docs) {
+    let doc = "*";
+    if (docs === undefined) {
+      return node;
+    }
+    for (const _doc of docs) {
+      if (Array.isArray(_doc)) {
+        try {
+          const sanitized = Bind.DocPart(_doc[0]);
+          for (const __doc of sanitized) {
+            if (__doc === "") {
+              doc += `
+ *`;
+            } else {
+              doc += `
+ * ${__doc}`;
+            }
+          }
+        } catch (e) {
+          console.log(node, docs);
+        }
+      } else {
+        if (_doc === "") {
+          doc += `
+ *`;
+        } else {
+          doc += `
+ * ${_doc}`;
+        }
+      }
+    }
+    return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `${doc}
+ `, true);
+  }
+}
+
+// src/typegen/mcdoc/primitives/int.ts
+import * as mcdoc from "@spyglassmc/mcdoc";
+import ts2 from "typescript";
+var { factory: factory2 } = ts2;
+var NBTIntType = "NBTInt";
+function mcdoc_int(type) {
+  const int = type;
+  Assert.NumericType(int);
+  return (args) => {
+    if (int.valueRange === undefined) {
+      return {
+        type: factory2.createTypeReferenceNode(NBTIntType),
+        imports: {
+          ordered: [`sandstone::${NBTIntType}`],
+          check: new Map([[`sandstone::${NBTIntType}`, 0]])
+        }
+      };
+    } else {
+      return whole_number_generic(int.valueRange, NBTIntType);
+    }
+  };
+}
+var McdocInt = mcdoc_int;
+function whole_number_generic(range, type) {
+  const docs = [
+    `Range: ${mcdoc.NumericRange.toString(range)}`
+  ];
+  const generic = [];
+  let has_min = false;
+  let has_max = false;
+  const left_exclusive = mcdoc.RangeKind.isLeftExclusive(range.kind);
+  const right_exclusive = mcdoc.RangeKind.isRightExclusive(range.kind);
+  if (range.min !== undefined) {
+    has_min = true;
+    if (left_exclusive) {
+      docs.push(`Effective minimum: ${range.min + 1}`);
+    }
+  }
+  if (range.max !== undefined) {
+    has_max = true;
+    if (right_exclusive) {
+      docs.push(`Effective maximum: ${range.max - 1}`);
+    }
+  }
+  if (has_min && has_max) {
+    if (integer_range_size(range.min, range.max) <= 100) {
+      generic.push(factory2.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(range.min + (left_exclusive ? 1 : 0))), factory2.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(range.max - (right_exclusive ? 1 : 0))));
+    } else if (range.min >= 0) {
+      let number = 0;
+      if (left_exclusive && range.min === 0 || range.min >= 1) {
+        number = 1;
+      }
+      generic.push(factory2.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(number)));
+    }
+  } else if (has_min) {
+    if (range.min >= 0) {
+      let number = 0;
+      if (left_exclusive && range.min === 0 || range.min >= 1) {
+        number = 1;
+      }
+      generic.push(factory2.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(number)));
+    } else if (left_exclusive) {
+      generic.push(factory2.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(range.min)));
+    }
+  } else {
+    if (range.max < 0 || right_exclusive && range.max === 0) {
+      generic.push(factory2.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(-1)));
+    } else if (right_exclusive) {
+      generic.push(factory2.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(range.max)));
+    }
+  }
+  return {
+    type: factory2.createTypeReferenceNode(type, [
+      factory2.createTypeLiteralNode(generic)
+    ]),
+    docs,
+    imports: {
+      ordered: [`sandstone::${type}`],
+      check: new Map([[`sandstone::${type}`, 0]])
+    }
+  };
+}
+function integer_range_size(lower, upper) {
+  if (lower > upper) {
+    throw new Error(`[mcdoc_int] Invalid integer range: lower bound (${lower}) must be <= upper bound (${upper})`);
+  }
+  if (upper < 0) {
+    return lower * -1 - upper * -1;
+  }
+  if (lower < 0) {
+    return lower * -1 + upper;
+  }
+  return upper - lower;
+}
+
+// src/typegen/mcdoc/list/list.ts
+var { factory: factory3 } = ts3;
+var NBTListType = "NBTList";
+var NBTListImport = `sandstone::${NBTListType}`;
+function mcdoc_list(type) {
+  const list = type;
+  Assert.ListType(list);
+  return (args) => {
+    args.root_type = false;
+    const item = TypeHandlers[list.item.kind](list.item)(args);
+    let imports = "imports" in item ? item.imports : undefined;
+    const child_dispatcher = "child_dispatcher" in item ? item.child_dispatcher.map(([parent_count, property]) => {
+      if (parent_count === 0) {
+        throw new Error(`[mcdoc_list] List contains a dynamic dispatcher with invalid parenting: ${item}`);
+      }
+      return [parent_count - 1, property];
+    }) : undefined;
+    if (list.lengthRange) {
+      const { generic, docs } = length_range_generic(list.lengthRange, "List");
+      imports = add_import(imports, NBTListImport);
+      const list_type = factory3.createTypeReferenceNode(NBTListType, [
+        item.type,
+        factory3.createTypeLiteralNode(generic)
+      ]);
+      Object.assign(list_type, { "--mcdoc_has_non_indexable": true });
+      return {
+        type: list_type,
+        docs,
+        ...add({ imports, child_dispatcher })
+      };
+    } else {
+      const array_type = factory3.createTypeReferenceNode("Array", [item.type]);
+      Object.assign(array_type, { "--mcdoc_has_non_indexable": true });
+      return {
+        type: array_type,
+        ...add({ imports, child_dispatcher })
+      };
+    }
+  };
+}
+var McdocList = mcdoc_list;
+function length_range_generic(range, label) {
+  const docs = [
+    `${label} length range: ${mcdoc2.NumericRange.toString(range)}`
+  ];
+  const generic = [];
+  let has_min = false;
+  let has_max = false;
+  const left_exclusive = mcdoc2.RangeKind.isLeftExclusive(range.kind);
+  const right_exclusive = mcdoc2.RangeKind.isRightExclusive(range.kind);
+  if (range.min !== undefined) {
+    has_min = true;
+    generic.push(factory3.createPropertySignature(undefined, "leftExclusive", undefined, factory3.createLiteralTypeNode(left_exclusive ? factory3.createTrue() : factory3.createFalse())));
+    if (left_exclusive) {
+      docs.push(`Effective minimum ${label.toLowerCase()} length: ${range.min + 1}`);
+    }
+  }
+  if (range.max !== undefined) {
+    has_max = true;
+    generic.push(factory3.createPropertySignature(undefined, "rightExclusive", undefined, factory3.createLiteralTypeNode(right_exclusive ? factory3.createTrue() : factory3.createFalse())));
+    if (right_exclusive) {
+      docs.push(`Effective maximum ${label.toLowerCase()} length: ${range.max - 1}`);
+    }
+  }
+  if (has_min && has_max) {
+    if (integer_range_size(range.min, range.max) <= 100) {
+      generic.push(factory3.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(range.min + (left_exclusive ? 1 : 0))), factory3.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(range.max - (right_exclusive ? 1 : 0))));
+    }
+  } else if (has_min) {
+    if (range.min >= 0) {
+      let number = 0;
+      if (left_exclusive && range.min === 0 || range.min >= 1) {
+        number = 1;
+      }
+      generic.push(factory3.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(number)));
+    } else if (left_exclusive) {
+      generic.push(factory3.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(range.min)));
+    }
+  } else {
+    if (range.max < 0 || right_exclusive && range.max === 0) {
+      generic.push(factory3.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(-1)));
+    } else if (right_exclusive) {
+      generic.push(factory3.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(range.max)));
+    }
+  }
+  return { generic, docs };
+}
+// src/typegen/mcdoc/list/array/byte.ts
+import ts4 from "typescript";
+var { factory: factory4 } = ts4;
+var NBTByteArrayType = "NBTByteArray";
+var NBTByteArrayImport = `sandstone::${NBTByteArrayType}`;
+function mcdoc_byte_array(type) {
+  Assert.ArrayType(type);
+  return (args) => {
+    const imports = {
+      ordered: [NBTByteArrayImport],
+      check: new Map([[NBTByteArrayImport, 0]])
+    };
+    if (type.lengthRange) {
+      const { generic, docs } = length_range_generic(type.lengthRange, "Array");
+      return {
+        type: factory4.createTypeReferenceNode(NBTByteArrayType, [
+          factory4.createTypeLiteralNode(generic)
+        ]),
+        imports,
+        docs
+      };
+    } else {
+      return {
+        type: factory4.createTypeReferenceNode(NBTByteArrayType),
+        imports
+      };
+    }
+  };
+}
+var McdocByteArray = mcdoc_byte_array;
+// src/typegen/mcdoc/list/array/int.ts
+import ts5 from "typescript";
+var { factory: factory5 } = ts5;
+var NBTIntArrayType = "NBTIntArray";
+var NBTIntArrayImport = `sandstone::${NBTIntArrayType}`;
+function mcdoc_int_array(type) {
+  Assert.ArrayType(type);
+  return (args) => {
+    const imports = {
+      ordered: [NBTIntArrayImport],
+      check: new Map([[NBTIntArrayImport, 0]])
+    };
+    if (type.lengthRange) {
+      const { generic, docs } = length_range_generic(type.lengthRange, "Array");
+      return {
+        type: factory5.createTypeReferenceNode(NBTIntArrayType, [
+          factory5.createTypeLiteralNode(generic)
+        ]),
+        imports,
+        docs
+      };
+    } else {
+      return {
+        type: factory5.createTypeReferenceNode(NBTIntArrayType),
+        imports
+      };
+    }
+  };
+}
+var McdocIntArray = mcdoc_int_array;
+// src/typegen/mcdoc/list/array/long.ts
+import ts6 from "typescript";
+var { factory: factory6 } = ts6;
+var NBTLongArrayType = "NBTLongArray";
+var NBTLongArrayImport = `sandstone::${NBTLongArrayType}`;
+function mcdoc_long_array(type) {
+  Assert.ArrayType(type);
+  return (args) => {
+    const imports = {
+      ordered: [NBTLongArrayImport],
+      check: new Map([[NBTLongArrayImport, 0]])
+    };
+    if (type.lengthRange) {
+      const { generic, docs } = length_range_generic(type.lengthRange, "Array");
+      return {
+        type: factory6.createTypeReferenceNode(NBTLongArrayType, [
+          factory6.createTypeLiteralNode(generic)
+        ]),
+        imports,
+        docs
+      };
+    } else {
+      return {
+        type: factory6.createTypeReferenceNode(NBTLongArrayType),
+        imports
+      };
+    }
+  };
+}
+var McdocLongArray = mcdoc_long_array;
+// src/typegen/mcdoc/primitives/any.ts
+import ts7 from "typescript";
+var { factory: factory7 } = ts7;
+var static_value = {
+  type: factory7.createKeywordTypeNode(ts7.SyntaxKind.UnknownKeyword)
+};
+function mcdoc_any(type) {
+  const any = type;
+  Assert.KeywordType(any);
+  return (args) => static_value;
+}
+var McdocAny = mcdoc_any;
+// src/typegen/mcdoc/primitives/boolean.ts
+import ts8 from "typescript";
+var { factory: factory8 } = ts8;
+var static_value2 = {
+  type: factory8.createKeywordTypeNode(ts8.SyntaxKind.BooleanKeyword)
+};
+function mcdoc_boolean(type) {
+  const boolean = type;
+  Assert.KeywordType(boolean);
+  return (args) => static_value2;
+}
+var McdocBoolean = mcdoc_boolean;
+// src/typegen/mcdoc/primitives/byte.ts
+import ts9 from "typescript";
+var { factory: factory9 } = ts9;
+var NBTByteType = "NBTByte";
+function mcdoc_byte(type) {
+  const byte = type;
+  Assert.NumericType(byte);
+  return (args) => {
+    if (byte.valueRange === undefined) {
+      return {
+        type: factory9.createTypeReferenceNode(NBTByteType),
+        imports: {
+          ordered: [`sandstone::${NBTByteType}`],
+          check: new Map([[`sandstone::${NBTByteType}`, 0]])
+        }
+      };
+    } else {
+      return whole_number_generic(byte.valueRange, NBTByteType);
+    }
+  };
+}
+var McdocByte = mcdoc_byte;
+// src/typegen/mcdoc/primitives/concrete.ts
+import ts10 from "typescript";
+function mcdoc_concrete(type) {
+  Assert.ConcreteType(type);
+  return (args) => {
+    const generic_types = [];
+    let imports = undefined;
+    let child_dispatcher;
+    for (const generic of type.typeArgs) {
+      const generic_type = TypeHandlers[generic.kind](generic)(args);
+      if ("imports" in generic_type) {
+        imports = merge_imports(imports, generic_type.imports);
+      }
+      if ("child_dispatcher" in generic_type) {
+        if (child_dispatcher === undefined) {
+          child_dispatcher = [];
+        }
+        child_dispatcher.push(...generic_type.child_dispatcher);
+      }
+      generic_types.push(generic_type.type);
+    }
+    const child = TypeHandlers[type.child.kind](type.child)({ ...args, generic_types });
+    if ("imports" in child) {
+      imports = merge_imports(imports, child.imports);
+    }
+    if ("child_dispatcher" in child) {
+      if (child_dispatcher === undefined) {
+        child_dispatcher = [];
+      }
+      child_dispatcher.push(...child.child_dispatcher);
+    }
+    return {
+      type: child.type,
+      ...add({ imports, child_dispatcher })
+    };
+  };
+}
+var McdocConcrete = mcdoc_concrete;
+// src/typegen/mcdoc/primitives/double.ts
+import * as mcdoc3 from "@spyglassmc/mcdoc";
+import ts11 from "typescript";
+var { factory: factory10 } = ts11;
+var NBTDoubleType = "NBTDouble";
+function mcdoc_double(type) {
+  const double = type;
+  Assert.NumericType(double);
+  return (args) => {
+    if (double.valueRange === undefined) {
+      return {
+        type: factory10.createParenthesizedType(factory10.createUnionTypeNode([
+          factory10.createTypeReferenceNode(NBTDoubleType),
+          factory10.createKeywordTypeNode(ts11.SyntaxKind.NumberKeyword)
+        ])),
+        imports: {
+          ordered: [`sandstone::${NBTDoubleType}`],
+          check: new Map([[`sandstone::${NBTDoubleType}`, 0]])
+        }
+      };
+    } else {
+      return non_integral_generic(double.valueRange, NBTDoubleType, true);
+    }
+  };
+}
+var McdocDouble = mcdoc_double;
+function non_integral_generic(range, type, allow_js_number) {
+  const docs = [
+    `Range: ${mcdoc3.NumericRange.toString(range)}`
+  ];
+  const generic = [];
+  let has_min = false;
+  let has_max = false;
+  const left_exclusive = mcdoc3.RangeKind.isLeftExclusive(range.kind);
+  const right_exclusive = mcdoc3.RangeKind.isRightExclusive(range.kind);
+  if (range.min !== undefined) {
+    has_min = true;
+    generic.push(factory10.createPropertySignature(undefined, "leftExclusive", undefined, factory10.createLiteralTypeNode(left_exclusive ? factory10.createTrue() : factory10.createFalse())));
+    if (left_exclusive) {
+      docs.push(`Minimum is exclusive; must be higher than ${range.min}`);
+    }
+  }
+  if (range.max !== undefined) {
+    has_max = true;
+    generic.push(factory10.createPropertySignature(undefined, "rightExclusive", undefined, factory10.createLiteralTypeNode(right_exclusive ? factory10.createTrue() : factory10.createFalse())));
+    if (right_exclusive) {
+      docs.push(`Maximum is exclusive; must be lower than ${range.max}`);
+    }
+  }
+  if (has_min && has_max) {
+    if (range.min === 0 && range.max === 1) {
+      generic.push(factory10.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(0)));
+      generic.push(factory10.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(1)));
+    } else if (range.min >= 0) {
+      let number = 0;
+      if (left_exclusive && range.min === 0 || range.min >= 1) {
+        number = 1;
+      }
+      generic.push(factory10.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(number)));
+      if (right_exclusive) {
+        generic.push(factory10.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(range.max)));
+      }
+    } else if (left_exclusive) {
+      generic.push(factory10.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(range.min)));
+      if (right_exclusive) {
+        generic.push(factory10.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(range.max)));
+      }
+    }
+  } else if (has_min) {
+    if (range.min >= 0) {
+      let number = 0;
+      if (left_exclusive && range.min === 0 || range.min >= 1) {
+        number = 1;
+      }
+      generic.push(factory10.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(number)));
+    } else if (left_exclusive) {
+      generic.push(factory10.createPropertySignature(undefined, "min", undefined, Bind.NumericLiteral(range.min)));
+    }
+  } else {
+    if (range.max < 0 || right_exclusive && range.max === 0) {
+      generic.push(factory10.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(-1)));
+    } else if (right_exclusive) {
+      generic.push(factory10.createPropertySignature(undefined, "max", undefined, Bind.NumericLiteral(range.max)));
+    }
+  }
+  const returned_type = allow_js_number ? factory10.createParenthesizedType(factory10.createUnionTypeNode([
+    factory10.createTypeReferenceNode(type, [
+      factory10.createTypeLiteralNode(generic)
+    ]),
+    factory10.createKeywordTypeNode(ts11.SyntaxKind.NumberKeyword)
+  ])) : factory10.createTypeReferenceNode(type, [
+    factory10.createTypeLiteralNode(generic)
+  ]);
+  return {
+    type: returned_type,
+    docs,
+    imports: {
+      ordered: [`sandstone::${type}`],
+      check: new Map([[`sandstone::${type}`, 0]])
+    }
+  };
+}
+// src/typegen/mcdoc/primitives/float.ts
+import ts12 from "typescript";
+var { factory: factory11 } = ts12;
+var NBTFloatType = "NBTFloat";
+function mcdoc_float(type) {
+  const float = type;
+  Assert.NumericType(float);
+  return (args) => {
+    if (float.valueRange === undefined) {
+      return {
+        type: factory11.createTypeReferenceNode(NBTFloatType),
+        imports: {
+          ordered: [`sandstone::${NBTFloatType}`],
+          check: new Map([[`sandstone::${NBTFloatType}`, 0]])
+        }
+      };
+    } else {
+      return non_integral_generic(float.valueRange, NBTFloatType);
+    }
+  };
+}
+var McdocFloat = mcdoc_float;
+// src/typegen/mcdoc/primitives/literal.ts
+import ts13 from "typescript";
+import { match as match2 } from "ts-pattern";
+var { factory: factory12 } = ts13;
+var boolean_static = {
+  true: {
+    type: factory12.createLiteralTypeNode(factory12.createTrue())
+  },
+  false: {
+    type: factory12.createLiteralTypeNode(factory12.createFalse())
+  }
+};
+function mcdoc_literal(type) {
+  const literal = type;
+  Assert.LiteralType(literal);
+  return (args) => match2(literal.value).with({ kind: "boolean" }, (boolean) => match2(boolean.value).with(true, () => boolean_static.true).with(false, () => boolean_static.false).exhaustive()).with({ kind: "byte" }, (byte) => {
+    const type2 = "NBTByte";
+    return {
+      type: factory12.createTypeReferenceNode(type2, [
+        Bind.NumericLiteral(byte.value)
+      ]),
+      imports: {
+        ordered: [`sandstone::${type2}`],
+        check: new Map([[`sandstone::${type2}`, 0]])
+      }
+    };
+  }).narrow().with({ kind: "double" }, { kind: "int" }, (num) => ({
+    type: Bind.NumericLiteral(num.value)
+  })).with({ kind: "float" }, (float) => {
+    const type2 = "NBTFloat";
+    return {
+      type: factory12.createTypeReferenceNode(type2, [
+        Bind.NumericLiteral(float.value)
+      ]),
+      imports: {
+        ordered: [`sandstone::${type2}`],
+        check: new Map([[`sandstone::${type2}`, 0]])
+      }
+    };
+  }).with({ kind: "long" }, (long) => {
+    const type2 = "NBTLong";
+    return {
+      type: factory12.createTypeReferenceNode(type2, [
+        Bind.StringLiteral(`${long.value}`)
+      ]),
+      imports: {
+        ordered: [`sandstone::${type2}`],
+        check: new Map([[`sandstone::${type2}`, 0]])
+      }
+    };
+  }).with({ kind: "short" }, (short) => {
+    const type2 = "NBTShort";
+    return {
+      type: factory12.createTypeReferenceNode(type2, [
+        Bind.NumericLiteral(short.value)
+      ]),
+      imports: {
+        ordered: [`sandstone::${type2}`],
+        check: new Map([[`sandstone::${type2}`, 0]])
+      }
+    };
+  }).with({ kind: "string" }, (string) => ({
+    type: Bind.StringLiteral(string.value)
+  })).exhaustive();
+}
+var McdocLiteral = mcdoc_literal;
+// src/typegen/mcdoc/primitives/long.ts
+import ts14 from "typescript";
+var { factory: factory13 } = ts14;
+var NBTLongType = "NBTLong";
+function mcdoc_long(type) {
+  const long = type;
+  Assert.NumericType(long);
+  return (args) => {
+    if (long.valueRange === undefined) {
+      return {
+        type: factory13.createTypeReferenceNode(NBTLongType),
+        imports: {
+          ordered: [`sandstone::${NBTLongType}`],
+          check: new Map([[`sandstone::${NBTLongType}`, 0]])
+        }
+      };
+    } else {
+      return whole_number_generic(long.valueRange, NBTLongType);
+    }
+  };
+}
+var McdocLong = mcdoc_long;
+// src/typegen/mcdoc/primitives/reference.ts
+import ts16 from "typescript";
+
+// src/typegen/mcdoc/multi/enum.ts
+import ts15 from "typescript";
+var { factory: factory14 } = ts15;
+function enum_docs(enum_type) {
+  const docs = [""];
+  for (const member of enum_type.values) {
+    const id_value = `${member.identifier}(\`${member.value}\`)`;
+    if (member.desc) {
+      const member_doc = Bind.DocPart(member.desc);
+      if (member_doc.length > 1) {
+        docs.push(` - ${id_value}:`);
+        docs.push(...member_doc.map((doc) => `   ${doc}`));
+      } else {
+        docs.push(` - ${id_value}: ${member_doc[0]}`);
+      }
+    } else {
+      docs.push(` - ${id_value}`);
+    }
+  }
+  return docs;
+}
+function mcdoc_enum(type) {
+  const enum_type = type;
+  Assert.EnumType(enum_type);
+  return (args) => {
+    const bind_value = (() => enum_type.enumKind === "string" ? (value) => Bind.StringLiteral(value) : (value) => Bind.NumericLiteral(value))();
+    const members = enum_type.values.map(({ value }) => bind_value(value));
+    return {
+      type: factory14.createParenthesizedType(factory14.createUnionTypeNode(members))
+    };
+  };
+}
+var McdocEnum = mcdoc_enum;
+
+// src/typegen/mcdoc/primitives/reference.ts
+var { factory: factory15 } = ts16;
+function ReferenceArgs(args) {}
+function mcdoc_reference(type) {
+  const reference = type;
+  Assert.ReferenceType(reference);
+  return (args) => {
+    ReferenceArgs(args);
+    let import_path = reference.path;
+    const initial_peek = args.module_map[reference.path]?.data;
+    if (initial_peek !== undefined && initial_peek !== null && typeof initial_peek === "object" && "typeDef" in initial_peek) {
+      const initial_type = initial_peek.typeDef;
+      if (initial_type.kind === "reference" && !(("attributes" in initial_type) && Array.isArray(initial_type.attributes) && initial_type.attributes.length > 0)) {
+        import_path = initial_type.path;
+      }
+    }
+    const type_name_point = import_path.lastIndexOf(":");
+    const type_name = import_path.slice(type_name_point + 1);
+    const base_path = import_path.slice(0, type_name_point - 1);
+    if ("dispatcher_symbol" in args) {
+      const dispatcher = args.dispatcher_symbol();
+      const location_counts_index = dispatcher.locations.get(base_path);
+      if (location_counts_index === undefined) {
+        dispatcher.locations.set(base_path, dispatcher.location_counts.length);
+        dispatcher.location_counts.push([base_path, 1]);
+      } else {
+        dispatcher.location_counts[location_counts_index][1]++;
+      }
+    }
+    const imports = args.module_path === base_path ? undefined : {
+      ordered: [import_path],
+      check: new Map([[import_path, 0]])
+    };
+    let docs;
+    let child_dispatcher;
+    let id_wrap = (ref) => ref;
+    const peek = args.module_map[import_path]?.data;
+    if (peek !== undefined && peek !== null && typeof peek === "object" && "typeDef" in peek) {
+      const referenced_type = peek.typeDef;
+      if (referenced_type.kind === "enum") {
+        docs = enum_docs(referenced_type);
+        if ("desc" in referenced_type && typeof referenced_type.desc === "string") {
+          docs.push("", [referenced_type.desc]);
+        }
+        if ("attributes" in type) {
+          Assert.Attributes(type.attributes, true);
+          if (type.attributes[0].name === "id" && type.attributes[0].value === undefined) {
+            id_wrap = (ref) => {
+              const id_ref = factory15.createParenthesizedType(factory15.createUnionTypeNode([
+                ref,
+                factory15.createTemplateLiteralType(factory15.createTemplateHead("minecraft:", "minecraft:"), [factory15.createTemplateLiteralTypeSpan(ref, factory15.createTemplateTail(""))])
+              ]));
+              Object.assign(id_ref, {
+                "--mcdoc_id_ref": {
+                  ref,
+                  alt: factory15.createParenthesizedType(factory15.createUnionTypeNode([
+                    factory15.createTypeReferenceNode("S"),
+                    factory15.createTemplateLiteralType(factory15.createTemplateHead("minecraft:", "minecraft:"), [factory15.createTemplateLiteralTypeSpan(factory15.createTypeReferenceNode("S"), factory15.createTemplateTail(""))])
+                  ]))
+                }
+              });
+              return id_ref;
+            };
+          }
+        }
+      } else if (referenced_type.kind === "struct" && args.spread) {
+        const generic_field = referenced_type.fields.find((f) => f.type.kind === "dispatcher" && f.type.parallelIndices[0].kind === "dynamic" && typeof f.type.parallelIndices[0].accessor[0] === "string" && ((key) => referenced_type.fields.findIndex((_f) => _f.kind === "pair" && _f.key === key))(f.type.parallelIndices[0].accessor[0]) === -1)?.type.parallelIndices[0].accessor[0];
+        if (generic_field !== undefined) {
+          child_dispatcher = [[0, generic_field]];
+          args.generic_types = [factory15.createTypeReferenceNode("S")];
+        }
+      } else if ("desc" in referenced_type && typeof referenced_type.desc === "string") {
+        docs = [[referenced_type.desc]];
+      }
+    }
+    if ("generic_types" in args) {
+      return {
+        type: factory15.createTypeReferenceNode(type_name, args.generic_types),
+        ...add({ imports, child_dispatcher, docs })
+      };
+    }
+    if ("generics" in args && args.generics.has(reference.path)) {
+      return {
+        type: factory15.createTypeReferenceNode(type_name),
+        ...add({ docs })
+      };
+    }
+    return {
+      type: id_wrap(factory15.createTypeReferenceNode(type_name)),
+      ...add({ imports, child_dispatcher, docs })
+    };
+  };
+}
+var McdocReference = mcdoc_reference;
+// src/typegen/mcdoc/primitives/short.ts
+import ts17 from "typescript";
+var { factory: factory16 } = ts17;
+var NBTShortType = "NBTShort";
+function mcdoc_short(type) {
+  const short = type;
+  Assert.NumericType(short);
+  return (args) => {
+    if (short.valueRange === undefined) {
+      return {
+        type: factory16.createTypeReferenceNode(NBTShortType),
+        imports: {
+          ordered: [`sandstone::${NBTShortType}`],
+          check: new Map([[`sandstone::${NBTShortType}`, 0]])
+        }
+      };
+    } else {
+      return whole_number_generic(short.valueRange, NBTShortType);
+    }
+  };
+}
+var McdocShort = mcdoc_short;
+// src/typegen/mcdoc/primitives/string.ts
+import ts18 from "typescript";
+import { match as match3, P as P3 } from "ts-pattern";
+import * as mcdoc4 from "@spyglassmc/mcdoc";
+var { factory: factory17 } = ts18;
+var StringKeyword = factory17.createKeywordTypeNode(ts18.SyntaxKind.StringKeyword);
+var static_value3 = {
+  normal: {
+    type: StringKeyword
+  },
+  not_empty: factory17.createTemplateLiteralType(factory17.createTemplateHead(""), [
+    factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.AnyKeyword), factory17.createTemplateMiddle("")),
+    factory17.createTemplateLiteralTypeSpan(StringKeyword, factory17.createTemplateTail(""))
+  ]),
+  namespaced_tag: {
+    type: factory17.createTemplateLiteralType(factory17.createTemplateHead("#"), [
+      factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.StringKeyword), factory17.createTemplateMiddle(":")),
+      factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.StringKeyword), factory17.createTemplateTail(""))
+    ])
+  },
+  namespaced: {
+    type: Bind.Namespaced
+  },
+  hash: {
+    type: factory17.createTemplateLiteralType(factory17.createTemplateHead("#"), [factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.StringKeyword), factory17.createTemplateTail(""))])
+  },
+  number: {
+    type: factory17.createTemplateLiteralType(factory17.createTemplateHead(""), [factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.NumberKeyword), factory17.createTemplateTail(""))])
+  },
+  time: {
+    type: factory17.createParenthesizedType(factory17.createUnionTypeNode([
+      factory17.createTemplateLiteralType(factory17.createTemplateHead(""), [
+        factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.NumberKeyword), factory17.createTemplateMiddle("-")),
+        factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.NumberKeyword), factory17.createTemplateMiddle("-")),
+        factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.NumberKeyword), factory17.createTemplateTail(""))
+      ]),
+      factory17.createTemplateLiteralType(factory17.createTemplateHead(""), [
+        factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.NumberKeyword), factory17.createTemplateMiddle(":")),
+        factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.NumberKeyword), factory17.createTemplateMiddle(":")),
+        factory17.createTemplateLiteralTypeSpan(factory17.createKeywordTypeNode(ts18.SyntaxKind.NumberKeyword), factory17.createTemplateTail(""))
+      ])
+    ]))
+  }
+};
+var ResourceClasses = {
+  "minecraft:advancement": "AdvancementClass",
+  "minecraft:function": "_RawFunctionClass"
+};
+function mcdoc_string(type) {
+  const string = type;
+  Assert.StringType(string);
+  if (string.attributes === undefined && string.lengthRange === undefined) {
+    return (args) => static_value3.normal;
+  } else if (string.attributes === undefined) {
+    return (args) => ({
+      type: static_value3.not_empty,
+      docs: [`String length range: ${mcdoc4.NumericRange.toString(string.lengthRange)}`]
+    });
+  } else {
+    Assert.Attributes(string.attributes, true);
+    const attribute = string.attributes.find((attr) => attr.name !== "since" && attr.name !== "until");
+    return match3(attribute).with(P3.nullish, () => {
+      return (args) => static_value3.normal;
+    }).with({ name: "id", value: P3.optional(P3.nullish) }, () => {
+      return (args) => static_value3.namespaced;
+    }).with({ name: "id", value: P3.nonNullable }, ({ value }) => {
+      const id_attr = value;
+      return (args) => {
+        const symbols = args.symbols;
+        let registry_id;
+        let exclude = (reg) => reg;
+        let Resource = () => (registry_id in ResourceClasses) ? ResourceClasses[registry_id] : undefined;
+        const registry_import = `::java::registry::Registry`;
+        const types = [];
+        let has_non_indexable = false;
+        const imports = {
+          ordered: [registry_import],
+          check: new Map([[registry_import, 0]])
+        };
+        if (id_attr.kind === "literal") {
+          registry_id = `minecraft:${id_attr.value.value}`;
+          if (is_valid_registry(symbols, registry_id)) {
+            types.push(exclude(factory17.createIndexedAccessTypeNode(factory17.createTypeReferenceNode("Registry"), Bind.StringLiteral(registry_id))));
+          } else {
+            types.push(static_value3.namespaced.type);
+          }
+        } else {
+          registry_id = `minecraft:${id_attr.values.registry.value.value}`;
+          let empty_registry = !is_valid_registry(symbols, registry_id);
+          if (!empty_registry) {
+            types.push(exclude(factory17.createIndexedAccessTypeNode(factory17.createTypeReferenceNode("Registry"), Bind.StringLiteral(registry_id))));
+          } else {
+            types.push(static_value3.namespaced.type);
+          }
+          if ("path" in id_attr.values) {
+            return {
+              type: static_value3.namespaced.type,
+              docs: ["", `Value: A ${registry_id} ID within a path root of \`(namespace)/textures/${id_attr.values.path.value.value}\``]
+            };
+          }
+          if ("definition" in id_attr.values) {
+            return {
+              type: static_value3.namespaced.type,
+              docs: ["", `Value: Defines a \`${registry_id}\` id.`]
+            };
+          }
+          if ("exclude" in id_attr.values) {
+            exclude = (reg) => factory17.createTypeReferenceNode("Exclude", [
+              reg,
+              factory17.createParenthesizedType(factory17.createUnionTypeNode(Object.values(id_attr.values.exclude.values).map((literal) => Bind.StringLiteral(literal.value.value))))
+            ]);
+          }
+          if ("tags" in id_attr.values) {
+            const Tag = "TagClass";
+            const tag_registry_id = registry_id.replace(":", ":tag/");
+            const empty_tag_registry = !is_valid_registry(symbols, tag_registry_id);
+            switch (id_attr.values.tags.value.value) {
+              case "allowed":
+                {
+                  types.push(empty_tag_registry ? static_value3.namespaced_tag.type : factory17.createTemplateLiteralType(factory17.createTemplateHead("#"), [factory17.createTemplateLiteralTypeSpan(factory17.createIndexedAccessTypeNode(factory17.createTypeReferenceNode("Registry"), Bind.StringLiteral(tag_registry_id)), factory17.createTemplateTail(""))]), factory17.createTypeReferenceNode(Tag, [Bind.StringLiteral(registry_id.split(":")[1])]));
+                  add_import(imports, `sandstone::${Tag}`);
+                  has_non_indexable = true;
+                }
+                break;
+              case "implicit": {
+                return {
+                  type: empty_tag_registry ? static_value3.namespaced.type : factory17.createParenthesizedType(factory17.createUnionTypeNode([
+                    factory17.createIndexedAccessTypeNode(factory17.createTypeReferenceNode("Registry"), Bind.StringLiteral(tag_registry_id))
+                  ])),
+                  imports
+                };
+              }
+              case "required": {
+                add_import(imports, "sandstone::TagClass");
+                return {
+                  type: factory17.createParenthesizedType(factory17.createUnionTypeNode([
+                    empty_tag_registry ? static_value3.namespaced_tag.type : factory17.createTemplateLiteralType(factory17.createTemplateHead("#"), [factory17.createTemplateLiteralTypeSpan(factory17.createIndexedAccessTypeNode(factory17.createTypeReferenceNode("Registry"), Bind.StringLiteral(tag_registry_id)), factory17.createTemplateTail(""))]),
+                    factory17.createTypeReferenceNode(Tag, [Bind.StringLiteral(registry_id.split(":")[1])])
+                  ])),
+                  imports
+                };
+              }
+            }
+          }
+          if ("empty" in id_attr.values) {
+            types.push(Bind.StringLiteral(""));
+          }
+          if ("prefix" in id_attr.values) {
+            throw new Error("[mcdoc_string] ID prefix is not currently supported as a value");
+          }
+        }
+        Resource = Resource();
+        if (Resource !== undefined) {
+          types.push(factory17.createTypeReferenceNode(Resource));
+          add_import(imports, `sandstone::${Resource}`);
+          has_non_indexable = true;
+        }
+        const result_type = types.length === 1 ? types[0] : factory17.createParenthesizedType(factory17.createUnionTypeNode(types));
+        if (has_non_indexable) {
+          Object.assign(result_type, { "--mcdoc_has_non_indexable": true });
+        }
+        return {
+          type: result_type,
+          imports
+        };
+      };
+    }).narrow().with({ name: "color" }, ({ value: { value: { value } } }) => {
+      Assert.ColorStringType(value);
+      return (args) => static_value3.hash;
+    }).with({ name: "command" }, ({ value: { values } }) => {
+      return (args) => ({ type: static_value3.not_empty });
+    }).with({ name: "crafting_ingredient" }, () => {
+      return (args) => ({ type: static_value3.not_empty });
+    }).with({ name: "criterion", value: P3.optional(P3.nullish) }, () => {
+      return (args) => ({ type: static_value3.not_empty });
+    }).with({ name: "entity" }, ({ value }) => {
+      let Target = "SingleEntityArgument";
+      if (value === undefined || value.values.amount?.value.value !== "single" && value.values.type?.value.value !== "players") {
+        Target = "MultipleEntitiesArgument";
+      } else if (value.values.amount?.value.value !== "single" && value.values.type?.value.value === "players") {
+        Target = "MultiplePlayersArgument";
+      } else if (value.values.amount?.value.value === "single" && value.values.type?.value.value === "players") {
+        Target = "SinglePlayerArgument";
+      }
+      return (args) => ({
+        type: factory17.createTypeReferenceNode(Target),
+        imports: {
+          ordered: [`sandstone::arguments::${Target}`],
+          check: new Map([[`sandstone::arguments::${Target}`, 0]])
+        }
+      });
+    }).with({ name: "integer" }, () => {
+      return (args) => static_value3.number;
+    }).with({ name: "item_slots" }, () => {
+      const ITEM_SLOTS = "ITEM_SLOTS";
+      const LiteralUnion = "LiteralUnion";
+      return (args) => ({
+        type: factory17.createTypeReferenceNode(LiteralUnion, [
+          factory17.createTypeReferenceNode(ITEM_SLOTS)
+        ]),
+        imports: {
+          ordered: [`sandstone::arguments::${ITEM_SLOTS}`, `sandstone::${LiteralUnion}`],
+          check: new Map([[`sandstone::arguments::${ITEM_SLOTS}`, 0], [`sandstone::${LiteralUnion}`, 1]])
+        }
+      });
+    }).with({ name: "nbt" }, ({ value }) => {
+      const NBT = "NBTClass";
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          factory17.createTypeReferenceNode(NBT)
+        ]),
+        imports: {
+          ordered: [`sandstone::${NBT}`],
+          check: new Map([[`sandstone::${NBT}`, 0]])
+        }
+      });
+    }).with({ name: "nbt_path" }, ({ value }) => {
+      const DataPoint = "DataPointClass";
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          factory17.createTypeReferenceNode(DataPoint)
+        ]),
+        imports: {
+          ordered: [`sandstone::${DataPoint}`],
+          check: new Map([[`sandstone::${DataPoint}`, 0]])
+        }
+      });
+    }).with({ name: "match_regex" }, ({ value: { value: { value } } }) => {
+      return (args) => ({
+        type: static_value3.not_empty,
+        docs: [`Must match regex of ${value}`]
+      });
+    }).with({ name: "objective" }, () => {
+      const Objective = "ObjectiveClass";
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          factory17.createTypeReferenceNode(Objective)
+        ]),
+        imports: {
+          ordered: [`sandstone::${Objective}`],
+          check: new Map([[`sandstone::${Objective}`, 0]])
+        }
+      });
+    }).with({ name: "regex_pattern" }, () => {
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          factory17.createTypeReferenceNode("RegExp")
+        ])
+      });
+    }).with({ name: "score_holder" }, () => {
+      const Score = "ScoreClass";
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          factory17.createTypeReferenceNode(Score)
+        ]),
+        imports: {
+          ordered: [`sandstone::${Score}`],
+          check: new Map([[`sandstone::${Score}`, 0]])
+        }
+      });
+    }).with({ name: "tag" }, () => {
+      const Label = "LabelClass";
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          factory17.createTypeReferenceNode(Label)
+        ]),
+        imports: {
+          ordered: [`sandstone::${Label}`],
+          check: new Map([[`sandstone::${Label}`, 0]])
+        }
+      });
+    }).with({ name: "team" }, () => {
+      return (args) => ({ type: static_value3.not_empty });
+    }).with({ name: "text_component" }, () => {
+      return (args) => ({ type: static_value3.not_empty });
+    }).with({ name: "texture_slot" }, ({ value: { values: { kind: { value: { value } } } } }) => {
+      const Texture = "TextureClass";
+      if (value === "reference") {
+        return (args) => static_value3.hash;
+      }
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          static_value3.hash.type,
+          factory17.createTypeReferenceNode(Texture)
+        ]),
+        imports: {
+          ordered: [`sandstone::${Texture}`],
+          check: new Map([[`sandstone::${Texture}`, 0]])
+        }
+      });
+    }).with({ name: "time_pattern" }, () => {
+      return (args) => static_value3.time;
+    }).with({ name: "translation_key" }, () => {
+      const TRANSLATION_KEYS = "TRANSLATION_KEYS";
+      const LiteralUnion = "LiteralUnion";
+      return (args) => ({
+        type: factory17.createTypeReferenceNode(LiteralUnion, [
+          factory17.createTypeReferenceNode(TRANSLATION_KEYS)
+        ]),
+        imports: {
+          ordered: [`sandstone::arguments::${TRANSLATION_KEYS}`, `sandstone::${LiteralUnion}`],
+          check: new Map([[`sandstone::arguments::${TRANSLATION_KEYS}`, 0], [`sandstone::${LiteralUnion}`, 1]])
+        }
+      });
+    }).with({ name: "translation_value" }, () => {
+      return (args) => static_value3.normal;
+    }).with({ name: "url" }, () => {
+      return (args) => ({
+        type: factory17.createUnionTypeNode([
+          static_value3.not_empty,
+          factory17.createTypeReferenceNode("URL")
+        ])
+      });
+    }).with({ name: "vector" }, ({ value: { values } }) => {
+      const Coordinates = "Coordinates";
+      return (args) => ({
+        type: factory17.createTypeReferenceNode(Coordinates),
+        imports: {
+          ordered: [`sandstone::arguments::${Coordinates}`],
+          check: new Map([[`sandstone::arguments::${Coordinates}`, 0]])
+        }
+      });
+    }).with({ name: P3.union("game_rule", "uuid", "block_predicate") }, () => {
+      return (args) => ({ type: static_value3.not_empty });
+    }).otherwise(() => {
+      console.log(attribute?.name);
+      throw new Error(`[mcdoc_string] Unsupported string attribute: ${attribute}`);
+    });
+  }
+}
+var McdocString = mcdoc_string;
+// src/typegen/mcdoc/multi/struct.ts
+import ts19 from "typescript";
+import { match as match4, P as P4 } from "ts-pattern";
+var { factory: factory18 } = ts19;
+function StructArgs(args) {}
+var FieldProperties = {
+  optional: P4.optional(P4.boolean),
+  deprecated: P4.optional(P4.boolean),
+  desc: P4.optional(P4.string),
+  attributes: P4.optional(P4.when((attributes) => Array.isArray(attributes)))
+};
+function mcdoc_struct(type) {
+  const struct = type;
+  Assert.StructType(struct);
+  return (args) => {
+    StructArgs(args);
+    const { name } = args;
+    const spread = args.spread ? true : false;
+    const root_type = args.root_type ? true : false;
+    delete args.spread;
+    args.root_type = false;
+    let imports = undefined;
+    const pair_indices = {};
+    const pairs = [];
+    const inherit = [];
+    let pair_inserted = false;
+    const merge = [];
+    let child_dispatcher;
+    for (const field of struct.fields) {
+      let unsupported = false;
+      if (field.attributes !== undefined) {
+        Assert.Attributes(field.attributes, true);
+        const attributes = field.attributes;
+        for (const attribute of attributes) {
+          if (attribute.name === "until" || attribute.name === "deprecated") {
+            unsupported = true;
+            break;
+          }
+        }
+      }
+      if (unsupported) {
+        continue;
+      }
+      match4(field).with({ kind: "pair", key: P4.string, ...FieldProperties }, (pair) => {
+        const value = TypeHandlers[pair.type.kind](pair.type)({ ...args, name: `${name}${pascal_case(pair.key)}` });
+        if ("imports" in value) {
+          imports = merge_imports(imports, value.imports);
+        }
+        if ("child_dispatcher" in value) {
+          if (child_dispatcher === undefined) {
+            child_dispatcher = [];
+          }
+          child_dispatcher.push(...value.child_dispatcher);
+        }
+        let field_docs = undefined;
+        if ("desc" in pair && typeof pair.desc === "string") {
+          if (field_docs === undefined) {
+            field_docs = [[pair.desc]];
+          } else {
+            field_docs.push([pair.desc]);
+          }
+        }
+        if ("docs" in value) {
+          if (field_docs === undefined) {
+            field_docs = ["Value:", ...value.docs];
+          } else {
+            field_docs.push("", "Value:", ...value.docs);
+          }
+        }
+        pair_indices[pair.key] = pairs.length;
+        pairs.push(Bind.Doc(factory18.createPropertySignature(undefined, pair.key, pair.optional ? factory18.createToken(ts19.SyntaxKind.QuestionToken) : undefined, value.type), field_docs));
+        pair_inserted = true;
+      }).narrow().with({ kind: "pair" }, (pair) => {
+        Assert.StructKeyType(pair.key);
+        const value = TypeHandlers[pair.type.kind](pair.type)({ ...args, name: `${name}IndexSignature` });
+        if ("imports" in value) {
+          imports = merge_imports(imports, value.imports);
+        }
+        if ("child_dispatcher" in value) {
+          if (child_dispatcher === undefined) {
+            child_dispatcher = [];
+          }
+          child_dispatcher.push(...value.child_dispatcher);
+        }
+        match4(pair.key.kind).with("reference", "concrete", (kind) => {
+          const key = TypeHandlers[kind](pair.key)(args);
+          if ("imports" in key) {
+            imports = merge_imports(imports, key.imports);
+          }
+          inherit.push(Bind.MappedType(key.type, value.type));
+        }).with("string", () => {
+          if (pair.key.attributes === undefined) {
+            Assert.StringType(pair.key);
+            inherit.push(Bind.MappedType(("lengthRange" in pair.key && "min" in pair.key.lengthRange ? pair.key.lengthRange.min : 0) >= 1 ? Bind.NonEmptyString : factory18.createKeywordTypeNode(ts19.SyntaxKind.StringKeyword), value.type));
+          } else {
+            Assert.Attributes(pair.key.attributes, true);
+            const attribute = pair.key.attributes[0];
+            match4(attribute).with({ name: "id" }, (attr) => {
+              const id_attr = attr.value;
+              let registry_id;
+              if (id_attr === undefined) {
+                throw new Error(`[mcdoc_struct] #[id] on a struct key is currently not handled`);
+              }
+              if (id_attr.kind === "literal") {
+                registry_id = `minecraft:${id_attr.value.value}`;
+              } else {
+                registry_id = `minecraft:${id_attr.values.registry.value.value}`;
+              }
+              const symbols = "symbols" in args ? args.symbols : undefined;
+              if (!is_valid_registry(symbols, registry_id)) {
+                inherit.push(Bind.MappedType(Bind.Namespaced, value.type));
+                return;
+              }
+              const registry_import = `::java::registry::Registry`;
+              imports = add_import(imports, registry_import);
+              inherit.push(Bind.MappedType(factory18.createIndexedAccessTypeNode(factory18.createTypeReferenceNode("Registry"), Bind.StringLiteral(registry_id)), value.type));
+            }).with({ name: "item_slots" }, () => {
+              const ITEM_SLOTS = "ITEM_SLOTS";
+              const LiteralUnion = "LiteralUnion";
+              imports = add_import(imports, `sandstone::arguments::${ITEM_SLOTS}`);
+              imports = add_import(imports, `sandstone::${LiteralUnion}`);
+              inherit.push(Bind.MappedType(factory18.createTypeReferenceNode(LiteralUnion, [
+                factory18.createTypeReferenceNode(ITEM_SLOTS)
+              ]), value.type));
+            }).with({ name: "objective" }, () => {
+              const Objective = "ObjectiveClass";
+              imports = add_import(imports, `sandstone::${Objective}`);
+              inherit.push(Bind.MappedType(factory18.createUnionTypeNode([
+                factory18.createKeywordTypeNode(ts19.SyntaxKind.StringKeyword),
+                factory18.createTypeReferenceNode(Objective)
+              ]), value.type));
+            }).with({ name: "texture_slot" }, () => {
+              inherit.push(Bind.MappedType(factory18.createKeywordTypeNode(ts19.SyntaxKind.StringKeyword), value.type));
+            }).with({ name: "criterion" }, () => {
+              inherit.push(Bind.MappedType(factory18.createKeywordTypeNode(ts19.SyntaxKind.StringKeyword), value.type));
+            }).with({ name: "crafting_ingredient" }, () => {
+              const CRAFTING_INGREDIENT = "CRAFTING_INGREDIENT";
+              imports = add_import(imports, `sandstone::arguments::${CRAFTING_INGREDIENT}`);
+              inherit.push(Bind.MappedType(factory18.createTypeReferenceNode(CRAFTING_INGREDIENT), value.type));
+            }).with({ name: P4.union("dispatcher_key", "translation_key", "permutation") }, () => {
+              inherit.push(Bind.MappedType(factory18.createKeywordTypeNode(ts19.SyntaxKind.StringKeyword), value.type));
+            }).otherwise(() => {
+              throw new Error(`[mcdoc_struct] Unsupported dynamic key attribute: ${attribute}`);
+            });
+          }
+        });
+      }).with({ kind: "spread" }, (_spread) => {
+        Assert.StructSpreadType(_spread.type);
+        const spread2 = TypeHandlers[_spread.type.kind](_spread.type)({ spread: true, ...args });
+        if ("imports" in spread2) {
+          imports = merge_imports(imports, spread2.imports);
+        }
+        if ("child_dispatcher" in spread2) {
+          if (child_dispatcher === undefined) {
+            child_dispatcher = [];
+          }
+          child_dispatcher.push(...spread2.child_dispatcher);
+        }
+        if (pair_inserted) {
+          merge.push(spread2.type);
+        } else {
+          inherit.push(spread2.type);
+        }
+      });
+    }
+    let inner_type;
+    let indexed_access;
+    let indexed_access_type;
+    let template = (type_node) => type_node;
+    if (child_dispatcher !== undefined && spread === false) {
+      const new_list = child_dispatcher.flatMap(([parent_count, property]) => {
+        if (parent_count === 0) {
+          if (indexed_access === property) {
+            return [];
+          }
+          const generic_prop = pair_indices[property];
+          if (generic_prop === undefined) {
+            if (root_type) {
+              template = (type_node) => factory18.createTypeAliasDeclaration([factory18.createToken(ts19.SyntaxKind.ExportKeyword)], args.name, [factory18.createTypeParameterDeclaration(undefined, "S", undefined, factory18.createKeywordTypeNode(ts19.SyntaxKind.UndefinedKeyword))], type_node);
+              return [];
+            }
+            throw new Error(`[mcdoc_struct] Received an invalid dynamic dispatcher trying to access '${property}'`);
+          }
+          indexed_access = property;
+          indexed_access_type = pairs[generic_prop].type;
+          if ("--mcdoc_has_non_indexable" in indexed_access_type) {
+            if (root_type) {
+              template = (type_node) => factory18.createTypeAliasDeclaration([factory18.createToken(ts19.SyntaxKind.ExportKeyword)], args.name, [factory18.createTypeParameterDeclaration(undefined, "S", undefined, factory18.createKeywordTypeNode(ts19.SyntaxKind.UndefinedKeyword))], type_node);
+            }
+          } else if ("--mcdoc_id_ref" in indexed_access_type) {
+            const id_ref = indexed_access_type["--mcdoc_id_ref"];
+            pairs[generic_prop].type = id_ref.alt;
+            indexed_access_type = id_ref.ref;
+          } else {
+            pairs[generic_prop].type = factory18.createTypeReferenceNode("S");
+          }
+          return [];
+        }
+        if (root_type) {
+          template = (type_node) => factory18.createTypeAliasDeclaration([factory18.createToken(ts19.SyntaxKind.ExportKeyword)], args.name, [factory18.createTypeParameterDeclaration(undefined, "S", undefined, factory18.createKeywordTypeNode(ts19.SyntaxKind.UndefinedKeyword))], type_node);
+        }
+        return [[parent_count - 1, property]];
+      });
+      child_dispatcher = new_list.length === 0 ? undefined : new_list;
+    }
+    const types = [...inherit];
+    if (pair_inserted) {
+      types.push(factory18.createTypeLiteralNode(pairs));
+    }
+    types.push(...merge);
+    if (types.length === 1) {
+      inner_type = types[0];
+    } else if (types.length > 1) {
+      inner_type = factory18.createParenthesizedType(factory18.createIntersectionTypeNode(types));
+    } else {
+      inner_type = Bind.EmptyObject;
+    }
+    if (indexed_access === undefined) {
+      return {
+        type: template(inner_type),
+        ...add({ imports, child_dispatcher })
+      };
+    } else if ("--mcdoc_has_non_indexable" in indexed_access_type) {
+      return {
+        type: template(inner_type),
+        ...add({ imports, child_dispatcher })
+      };
+    } else {
+      return {
+        type: template(factory18.createParenthesizedType(factory18.createIndexedAccessTypeNode(Bind.MappedType(indexed_access_type, inner_type, { key_name: "S", parenthesized: false }), indexed_access_type))),
+        ...add({ imports, child_dispatcher })
+      };
+    }
+  };
+}
+var McdocStruct = mcdoc_struct;
+// src/typegen/mcdoc/multi/tuple.ts
+import ts20 from "typescript";
+var { factory: factory19 } = ts20;
+function mcdoc_tuple(type) {
+  const tuple = type;
+  Assert.TupleType(tuple);
+  return (args) => {
+    args.root_type = false;
+    let imports = undefined;
+    const members = [];
+    let has_docs = false;
+    const member_docs = [];
+    let child_dispatcher;
+    for (const item of tuple.items) {
+      let unsupported = false;
+      if (item.attributes !== undefined) {
+        Assert.Attributes(item.attributes, true);
+        const attributes = item.attributes;
+        for (const attribute of attributes) {
+          if (attribute.name === "until" || attribute.name === "deprecated") {
+            unsupported = true;
+            break;
+          }
+        }
+      }
+      if (unsupported) {
+        continue;
+      }
+      const value = TypeHandlers[item.kind](item)(args);
+      if ("imports" in value) {
+        imports = merge_imports(imports, value.imports);
+      }
+      if ("child_dispatcher" in value) {
+        if (child_dispatcher === undefined) {
+          child_dispatcher = [];
+        }
+        child_dispatcher.push(...value.child_dispatcher.map(([parent_count, property]) => {
+          if (parent_count === 0) {
+            throw new Error(`[mcdoc_tuple] Tuple contains a dynamic dispatcher with invalid parenting: ${item}`);
+          }
+          return [parent_count - 1, property];
+        }));
+      }
+      if ("docs" in value) {
+        has_docs = true;
+        const docs2 = value.docs;
+        member_docs.push(value.docs);
+      } else {
+        member_docs.push(false);
+      }
+      members.push(value.type);
+    }
+    const docs = has_docs ? member_docs.flatMap((doc, i) => {
+      if (members.length === 1 && doc !== false) {
+        return [doc];
+      } else {
+        return [
+          ...doc === false ? [`*item ${i}*`] : [doc],
+          ...i !== member_docs.length - 1 ? ["", "*or*", ""] : []
+        ];
+      }
+    }) : undefined;
+    return {
+      type: factory19.createTupleTypeNode(members),
+      ...add({ imports, child_dispatcher, docs })
+    };
+  };
+}
+var McdocTuple = mcdoc_tuple;
+// src/typegen/mcdoc/multi/union.ts
+import ts21 from "typescript";
+var { factory: factory20 } = ts21;
+var Never = factory20.createKeywordTypeNode(ts21.SyntaxKind.NeverKeyword);
+function mcdoc_union(type) {
+  const union = type;
+  Assert.UnionType(union);
+  return (args) => {
+    args.root_type = false;
+    let imports = undefined;
+    const members = [];
+    let has_docs = false;
+    const member_docs = [];
+    let child_dispatcher;
+    for (const member of union.members) {
+      let unsupported = false;
+      if (member.attributes !== undefined) {
+        Assert.Attributes(member.attributes, true);
+        const attributes = member.attributes;
+        for (const attribute of attributes) {
+          if (attribute.name === "until" || attribute.name === "deprecated") {
+            unsupported = true;
+            break;
+          }
+        }
+      }
+      if (unsupported) {
+        continue;
+      }
+      const value = TypeHandlers[member.kind](member)(args);
+      if ("imports" in value) {
+        imports = merge_imports(imports, value.imports);
+      }
+      if ("child_dispatcher" in value) {
+        if (child_dispatcher === undefined) {
+          child_dispatcher = [];
+        }
+        child_dispatcher.push(...value.child_dispatcher);
+      }
+      if ("docs" in value) {
+        has_docs = true;
+        member_docs.push(value.docs);
+      } else {
+        member_docs.push(false);
+      }
+      members.push(value.type);
+    }
+    if (members.length === 0) {
+      if (union.members.length !== 0) {
+        console.log(union.members);
+      }
+      members.push(Never);
+    }
+    const docs = has_docs ? member_docs.flatMap((doc, i) => {
+      if (members.length === 1 && doc !== false) {
+        return doc;
+      } else {
+        return [
+          ...i === 0 ? ["*either*", ""] : [],
+          doc === false ? [`*item ${i}*`] : doc,
+          ...i !== member_docs.length - 1 ? ["", "*or*", ""] : []
+        ];
+      }
+    }) : undefined;
+    const result_type = members.length === 1 ? members[0] : factory20.createParenthesizedType(factory20.createUnionTypeNode(members));
+    if (members.some((m) => ("--mcdoc_has_non_indexable" in m))) {
+      Object.assign(result_type, { "--mcdoc_has_non_indexable": true });
+    }
+    return {
+      type: result_type,
+      ...add({ imports, child_dispatcher, docs })
+    };
+  };
+}
+var McdocUnion = mcdoc_union;
+// src/typegen/mcdoc/complex/dispatcher.ts
+import ts22 from "typescript";
+var { factory: factory21 } = ts22;
+function DispatcherArgs(args) {}
+var SimpleKeyIndex = JSON.stringify([{
+  kind: "dynamic",
+  accessor: [{
+    keyword: "key"
+  }]
+}]);
+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 DispatcherMapIndex(registry, key, generics) {
+  const dispatcher = factory21.createTypeReferenceNode("Dispatcher", [Bind.StringLiteral(registry), ...generics.length === 0 ? [] : [factory21.createTupleTypeNode(generics)]]);
+  if (key.kind === ts22.SyntaxKind.LiteralType) {
+    return factory21.createIndexedAccessTypeNode(dispatcher, key);
+  }
+  return factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, dispatcher), factory21.createIndexedAccessTypeNode(dispatcher, 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;
+  for (let i = sub_index.length;i > 0; i--) {
+    const key = Bind.StringLiteral(sub_index[i - 1]);
+    let index_stack = dispatcher_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);
+    }
+    indexed_dispatcher = factory21.createParenthesizedType(factory21.createConditionalTypeNode(key, factory21.createTypeOperatorNode(ts22.SyntaxKind.KeyOfKeyword, index_stack), indexed_dispatcher, 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", [
+    factory21.createKeywordTypeNode(ts22.SyntaxKind.StringKeyword),
+    factory21.createKeywordTypeNode(ts22.SyntaxKind.UnknownKeyword)
+  ])));
+}
+function mcdoc_dispatcher(type) {
+  Assert.DispatcherType(type);
+  const dispatcher = type;
+  const registry = dispatcher.registry;
+  const indices = dispatcher.parallelIndices;
+  return (args) => {
+    DispatcherArgs(args);
+    const dispatcher_import = `::java::dispatcher::Dispatcher`;
+    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]);
+      } else {
+        child_dispatcher = [[indices[0].accessor.length - 1, indices[0].accessor.at(-1)]];
+        const indexed_type = DispatcherMapIndex(registry, 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));
+        } 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]);
+      } else {
+        result_type = DispatcherMapIndex(registry, 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);
+      } else {
+        result_type = DispatcherMapIndex(registry, factory21.createTypeReferenceNode("Key"), generics);
+      }
+    } else {
+      throw new Error(`[mcdoc_dispatcher] Unsupported dispatcher: ${dispatcher}`);
+    }
+    return {
+      type: result_type,
+      imports: {
+        ordered: [dispatcher_import],
+        check: new Map([[dispatcher_import, 0]])
+      },
+      ...add({ child_dispatcher })
+    };
+  };
+}
+var McdocDispatcher = mcdoc_dispatcher;
+// src/typegen/mcdoc/complex/indexed.ts
+function mcdoc_indexed(type) {
+  Assert.IndexedType(type);
+  Assert.DispatcherType(type.child);
+  const indices = type.parallelIndices;
+  return (args) => {
+    const index_keys = indices.map((index) => index.value);
+    return McdocDispatcher(type.child)({ index_keys, ...args });
+  };
+}
+var McdocIndexed = mcdoc_indexed;
+// src/typegen/mcdoc/complex/template.ts
+import ts23 from "typescript";
+var { factory: factory22 } = ts23;
+function parse_template_args(args) {
+  if (!("name" in args)) {
+    throw new Error(`[mcdoc_template] template name must be included in TypeHandler args, got ${args}`);
+  }
+  return {
+    name: args.name
+  };
+}
+function mcdoc_template(type) {
+  Assert.TemplateType(type);
+  const original_generics = type.typeParams;
+  const child = type.child;
+  return (args) => {
+    const { name } = parse_template_args(args);
+    let imports = undefined;
+    let child_dispatcher;
+    const generic_paths = new Set;
+    const generics = [];
+    for (const generic of original_generics) {
+      generic_paths.add(generic.path);
+      generics.push(factory22.createTypeParameterDeclaration(undefined, generic.path.slice(generic.path.lastIndexOf(":") + 1)));
+    }
+    const child_result = TypeHandlers[child.kind](child)({
+      ...args,
+      root_type: false,
+      generics: generic_paths
+    });
+    if ("imports" in child_result) {
+      imports = merge_imports(imports, child_result.imports);
+    }
+    if ("child_dispatcher" in child_result) {
+      child_dispatcher = child_result.child_dispatcher;
+    }
+    const type_alias = factory22.createTypeAliasDeclaration([factory22.createModifier(ts23.SyntaxKind.ExportKeyword)], name, generics, child_result.type);
+    return {
+      type: type_alias,
+      ...add({ imports, child_dispatcher })
+    };
+  };
+}
+var McdocTemplate = mcdoc_template;
+// src/typegen/mcdoc/index.ts
+class TypeHandlersClass {
+  static any = McdocAny;
+  static boolean = McdocBoolean;
+  static byte = McdocByte;
+  static byte_array = McdocByteArray;
+  static concrete = McdocConcrete;
+  static dispatcher = McdocDispatcher;
+  static double = McdocDouble;
+  static enum = McdocEnum;
+  static float = McdocFloat;
+  static indexed = McdocIndexed;
+  static int = McdocInt;
+  static int_array = McdocIntArray;
+  static list = McdocList;
+  static literal = McdocLiteral;
+  static long = McdocLong;
+  static long_array = McdocLongArray;
+  static mapped = McdocAny;
+  static reference = McdocReference;
+  static short = McdocShort;
+  static string = McdocString;
+  static struct = McdocStruct;
+  static template = McdocTemplate;
+  static tuple = McdocTuple;
+  static union = McdocUnion;
+  static unsafe = McdocAny;
+}
+var TypeHandlers = TypeHandlersClass;
+function get_type_handler(type) {
+  return TypeHandlers[type.kind];
+}
+
+// src/typegen/mcdoc/dispatcher_symbol.ts
+import ts24 from "typescript";
+var { factory: factory23 } = ts24;
+var dispatcher_references = new Map;
+function dispatcher_symbol(id, name, members, dispatcher_properties, module_map, symbols) {
+  let imports = undefined;
+  let has_references = false;
+  const member_types = [];
+  const map_properties = [];
+  const member_type_refs = [];
+  const first_member = members[Object.keys(members)[0]];
+  const first_type = first_member.data.typeDef;
+  const has_generics = first_type.kind === "template";
+  const generic_params = [];
+  const generic_names = [];
+  if (has_generics && first_type.kind === "template") {
+    const template = first_type;
+    for (const type_param of template.typeParams) {
+      const param_name = type_param.path.split("::").pop();
+      generic_params.push(factory23.createTypeParameterDeclaration(undefined, param_name));
+      generic_names.push(factory23.createTypeReferenceNode(param_name));
+    }
+  }
+  const add_reference = () => {
+    has_references = true;
+    if (!dispatcher_references.has(id)) {
+      dispatcher_references.set(id, {
+        locations: new Map,
+        location_counts: []
+      });
+    }
+    return dispatcher_references.get(id);
+  };
+  let fallback_type_name;
+  if ("%unknown" in members) {
+    const unknown_member = members["%unknown"].data.typeDef;
+    const unknown_type_name = `${name}FallbackType`;
+    const result = get_type_handler(unknown_member)(unknown_member)({
+      root_type: true,
+      name: unknown_type_name,
+      dispatcher_symbol: add_reference,
+      dispatcher_properties,
+      module_map,
+      symbols
+    });
+    if ("imports" in result) {
+      imports = merge_imports(imports, result.imports);
+    }
+    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));
+    }
+  }
+  const has_none = "%none" in members;
+  if (has_none) {
+    const none_member = members["%none"].data.typeDef;
+    const none_type_name = `${name}NoneType`;
+    const result = get_type_handler(none_member)(none_member)({
+      root_type: true,
+      name: none_type_name,
+      dispatcher_symbol: add_reference,
+      dispatcher_properties,
+      module_map,
+      symbols
+    });
+    if ("imports" in result) {
+      imports = merge_imports(imports, result.imports);
+    }
+    dispatcher_properties.set(id, {
+      supports_none: true
+    });
+    if (ts24.isTypeAliasDeclaration(result.type)) {
+      member_types.push(result.type);
+    } else {
+      member_types.push(factory23.createTypeAliasDeclaration(undefined, none_type_name, undefined, result.type));
+    }
+  }
+  for (const member_key of Object.keys(members)) {
+    const member = members[member_key];
+    if (member_key.startsWith("%")) {
+      continue;
+    }
+    const member_type = member.data.typeDef;
+    const member_type_name = `${name}${pascal_case(member_key.replace(/[/:]/g, "_"))}`;
+    const result = get_type_handler(member_type)(member_type)({
+      root_type: true,
+      name: member_type_name,
+      dispatcher_symbol: add_reference,
+      dispatcher_properties,
+      module_map,
+      symbols
+    });
+    if ("imports" in result) {
+      imports = merge_imports(imports, result.imports);
+    }
+    if (ts24.isTypeAliasDeclaration(result.type)) {
+      member_types.push(result.type);
+    } else {
+      member_types.push(factory23.createTypeAliasDeclaration(undefined, member_type_name, undefined, result.type));
+    }
+    const member_ref = factory23.createTypeReferenceNode(member_type_name, has_generics ? generic_names : undefined);
+    member_type_refs.push(member_ref);
+    map_properties.push(factory23.createPropertySignature(undefined, factory23.createStringLiteral(member_key, true), undefined, member_ref), factory23.createPropertySignature(undefined, factory23.createStringLiteral(`minecraft:${member_key}`, true), undefined, member_ref));
+  }
+  const map_type = factory23.createTypeAliasDeclaration(undefined, `${name}DispatcherMap`, has_generics ? generic_params : undefined, factory23.createTypeLiteralNode(map_properties));
+  const keys_type = factory23.createTypeAliasDeclaration(undefined, `${name}Keys`, undefined, factory23.createTypeOperatorNode(ts24.SyntaxKind.KeyOfKeyword, factory23.createTypeReferenceNode(`${name}DispatcherMap`, has_generics ? generic_names.map(() => factory23.createKeywordTypeNode(ts24.SyntaxKind.UnknownKeyword)) : undefined)));
+  const fallback_union_members = fallback_type_name ? [...member_type_refs, fallback_type_name] : member_type_refs;
+  const fallback_type = factory23.createTypeAliasDeclaration(undefined, `${name}Fallback`, has_generics ? generic_params : undefined, factory23.createParenthesizedType(factory23.createUnionTypeNode(fallback_union_members)));
+  generic_params.push(factory23.createTypeParameterDeclaration(undefined, "CASE", factory23.createUnionTypeNode([
+    Bind.StringLiteral("map"),
+    Bind.StringLiteral("keys"),
+    Bind.StringLiteral("%fallback"),
+    Bind.StringLiteral("%none")
+  ]), Bind.StringLiteral("map")));
+  const symbol_type = factory23.createTypeAliasDeclaration([factory23.createModifier(ts24.SyntaxKind.ExportKeyword)], `Symbol${name}`, generic_params, factory23.createConditionalTypeNode(factory23.createTypeReferenceNode("CASE"), Bind.StringLiteral("map"), factory23.createTypeReferenceNode(`${name}DispatcherMap`, has_generics ? generic_names : undefined), factory23.createConditionalTypeNode(factory23.createTypeReferenceNode("CASE"), Bind.StringLiteral("keys"), factory23.createTypeReferenceNode(`${name}Keys`), factory23.createConditionalTypeNode(factory23.createTypeReferenceNode("CASE"), Bind.StringLiteral("%fallback"), factory23.createTypeReferenceNode(`${name}Fallback`, has_generics ? generic_names : undefined), has_none ? factory23.createConditionalTypeNode(factory23.createTypeReferenceNode("CASE"), Bind.StringLiteral("%none"), factory23.createTypeReferenceNode(`${name}NoneType`, has_generics ? generic_names : undefined), factory23.createKeywordTypeNode(ts24.SyntaxKind.NeverKeyword)) : factory23.createKeywordTypeNode(ts24.SyntaxKind.NeverKeyword)))));
+  return {
+    types: [
+      map_type,
+      keys_type,
+      fallback_type,
+      ...member_types,
+      symbol_type
+    ],
+    ...add({ imports }),
+    ...has_references ? { references: dispatcher_references.get(id) } : {},
+    generic_count: has_generics && first_type.kind === "template" ? first_type.typeParams.length : 0
+  };
+}
+var DispatcherSymbol = dispatcher_symbol;
+
+// src/typegen/export.ts
+import ts25 from "typescript";
+var { factory: factory24 } = ts25;
+function export_registry(resolved_registries) {
+  let imports;
+  const properties = [];
+  for (const [registry_name, { import_path, registry }] of resolved_registries) {
+    imports = add_import(imports, import_path);
+    const registry_id = registry_name.includes(":") ? registry_name : `minecraft:${registry_name}`;
+    properties.push(factory24.createPropertySignature(undefined, factory24.createStringLiteral(registry_id), undefined, factory24.createTypeReferenceNode(registry)));
+  }
+  const registry_type = factory24.createTypeAliasDeclaration([factory24.createToken(ts25.SyntaxKind.ExportKeyword)], "Registry", undefined, factory24.createTypeLiteralNode(properties));
+  return {
+    exports: [registry_type],
+    paths: new Set,
+    ...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;
+
+class TypesGenerator {
+  resolved_registries = new Map;
+  dispatcher_properties = new Map;
+  resolved_symbols = new Map;
+  resolved_dispatchers = new Map;
+  constructor() {}
+  resolve_types(symbols) {
+    console.log("registries");
+    this.resolve_registry_symbols(symbols);
+    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("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);
+  }
+  resolve_registry_symbols(registries) {
+    for (const registry_name of AllCategories) {
+      if (registry_name === "mcdoc" || registry_name === "mcdoc/dispatcher") {
+        continue;
+      }
+      const registry = Object.keys(registries.getVisibleSymbols(registry_name));
+      if (registry.length === 0)
+        continue;
+      const type_name = pluralize(registry_name.split("/").join("_")).toUpperCase();
+      const symbol_path = `::java::_registry::${type_name.toLowerCase()}`;
+      this.resolved_symbols.set(symbol_path, {
+        imports: {
+          check: new Map,
+          ordered: ["sandstone::NamespacedLiteralUnion", "sandstone::Set", "sandstone::SetType"]
+        },
+        exports: [
+          factory25.createTypeAliasDeclaration([factory25.createToken(ts26.SyntaxKind.ExportKeyword)], type_name, undefined, factory25.createParenthesizedType(factory25.createUnionTypeNode([
+            factory25.createTypeReferenceNode("NamespacedLiteralUnion", [factory25.createTypeReferenceNode(factory25.createIdentifier("SetType"), [factory25.createTypeQueryNode(factory25.createIdentifier(`${type_name}_SET`))])]),
+            factory25.createTemplateLiteralType(factory25.createTemplateHead("minecraft:"), [factory25.createTemplateLiteralTypeSpan(factory25.createTypeReferenceNode(factory25.createIdentifier("SetType"), [factory25.createTypeQueryNode(factory25.createIdentifier(`${type_name}_SET`))]), factory25.createTemplateTail(""))])
+          ]))),
+          factory25.createVariableStatement([factory25.createToken(ts26.SyntaxKind.ExportKeyword)], factory25.createVariableDeclarationList([factory25.createVariableDeclaration(`${type_name}_SET`, undefined, undefined, factory25.createNewExpression(factory25.createIdentifier("Set"), undefined, [factory25.createAsExpression(factory25.createArrayLiteralExpression(registry.map((s) => factory25.createStringLiteral(s.split(":")[1], true)), true), factory25.createTypeReferenceNode("const"))]))], ts26.NodeFlags.Const))
+        ],
+        paths: new Set2
+      });
+      this.resolved_registries.set(registry_name, {
+        registry: factory25.createIdentifier(type_name),
+        import_path: `${symbol_path}::${type_name}`
+      });
+    }
+  }
+  resolve_module_symbols(module_map, symbols) {
+    for (const _path of Object.keys(module_map)) {
+      const { data } = module_map[_path];
+      if (_path.endsWith(">")) {
+        continue;
+      }
+      const matches = mcdoc_raw.matchAll(new RegExp(_path, "g"));
+      const first_match = matches.next();
+      const second_match = matches.next();
+      if (!first_match.done && second_match.done) {
+        continue;
+      }
+      if (data !== null && typeof data === "object" && "typeDef" in data) {
+        const type = data.typeDef;
+        const path = _path.split("::");
+        const name = path.at(-1);
+        const module_path = path.slice(0, -1).join("::");
+        if (type.kind === "reference") {
+          const has_attrs = "attributes" in type && Array.isArray(type.attributes) && type.attributes.length > 0;
+          if (!has_attrs) {
+            continue;
+          }
+        }
+        const resolved_member = get_type_handler(type)(type)({
+          dispatcher_properties: this.dispatcher_properties,
+          root_type: true,
+          name,
+          module_path,
+          module_map,
+          symbols
+        });
+        const module = (() => {
+          if (!this.resolved_symbols.has(module_path)) {
+            return this.resolved_symbols.set(module_path, {
+              paths: new Set2([_path]),
+              exports: [],
+              ..."imports" in resolved_member ? { imports: resolved_member.imports } : {}
+            }).get(module_path);
+          }
+          const mod = this.resolved_symbols.get(module_path);
+          mod.paths.add(_path);
+          if ("imports" in resolved_member) {
+            mod.imports = merge_imports(mod.imports, resolved_member.imports);
+          }
+          return mod;
+        })();
+        if (ts26.isTypeAliasDeclaration(resolved_member.type)) {
+          module.exports.push(resolved_member.type);
+        } else {
+          module.exports.push(Bind.Doc(factory25.createTypeAliasDeclaration([factory25.createModifier(ts26.SyntaxKind.ExportKeyword)], name, undefined, resolved_member.type), resolved_member.docs));
+        }
+      }
+    }
+  }
+  resolve_dispatcher_symbols(dispatchers, module_map, symbols) {
+    for (const id of Object.keys(dispatchers)) {
+      const { members } = dispatchers[id];
+      if (members === undefined) {
+        continue;
+      }
+      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);
+      let in_module = false;
+      const symbol_path = (() => {
+        if (namespace === "mcdoc") {
+          return `::java::_builtin::${_name}`;
+        }
+        if (references !== undefined) {
+          const sorted = references.location_counts.sort((a, b) => b[1] - a[1]);
+          if (sorted.length === 1 || sorted[0][1] > sorted[1][1] + 5) {
+            in_module = true;
+            return sorted[0][0];
+          }
+        }
+        return `::java::_dispatcher::${_name}`;
+      })();
+      const dispatcher_type_name = `Symbol${name}`;
+      this.resolved_dispatchers.set(id, {
+        import_path: `${symbol_path}::${dispatcher_type_name}`,
+        type: factory25.createTypeReferenceNode(dispatcher_type_name),
+        generic_count,
+        symbol_name: dispatcher_type_name
+      });
+      if (in_module && this.resolved_symbols.has(symbol_path)) {
+        const mod = this.resolved_symbols.get(symbol_path);
+        mod.exports.push(...types);
+        if (imports !== undefined) {
+          for (const path of imports.ordered) {
+            if (!mod.paths.has(path)) {
+              mod.imports = add_import(mod.imports, path);
+            }
+          }
+        }
+      } else {
+        this.resolved_symbols.set(symbol_path, {
+          exports: types,
+          paths: new Set2,
+          ...add({ imports })
+        });
+      }
+    }
+  }
+}
+
+// src/typegen/compile.ts
+import ts27 from "typescript";
+import { ESLint } from "eslint";
+import stylistic from "@stylistic/eslint-plugin";
+import wrap from "@seahax/eslint-plugin-wrap";
+import tsparser from "@typescript-eslint/parser";
+var eslint = new ESLint({
+  fix: true,
+  overrideConfigFile: true,
+  overrideConfig: [
+    wrap.config({
+      maxLen: 120,
+      tabWidth: 4,
+      autoFix: true,
+      severity: "warn"
+    }),
+    {
+      files: ["**/*.ts"],
+      languageOptions: {
+        parser: tsparser,
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module"
+        }
+      },
+      plugins: {
+        "@stylistic": stylistic
+      },
+      rules: {
+        "@stylistic/indent": ["error", 4],
+        "@stylistic/quotes": ["error", "single"],
+        "@stylistic/semi": ["error", "never"],
+        "@stylistic/member-delimiter-style": ["error", {
+          multiline: { delimiter: "none" },
+          singleline: { delimiter: "comma", requireLast: false }
+        }],
+        "@stylistic/comma-dangle": ["error", "always-multiline"],
+        "@stylistic/object-curly-spacing": ["error", "always"],
+        "@stylistic/array-bracket-spacing": ["error", "never"],
+        "@stylistic/block-spacing": ["error", "always"],
+        "@stylistic/brace-style": ["error", "1tbs", { allowSingleLine: true }],
+        "@stylistic/key-spacing": ["error", { beforeColon: false, afterColon: true }],
+        "@stylistic/keyword-spacing": ["error", { before: true, after: true }],
+        "@stylistic/space-before-blocks": ["error", "always"],
+        "@stylistic/space-infix-ops": "error",
+        "@stylistic/eol-last": ["error", "always"],
+        "@stylistic/no-trailing-spaces": "error",
+        "@stylistic/no-multiple-empty-lines": ["error", { max: 1 }],
+        "@stylistic/padding-line-between-statements": [
+          "error",
+          { blankLine: "always", prev: "export", next: "export" },
+          { blankLine: "always", prev: "import", next: "*" },
+          { blankLine: "never", prev: "import", next: "import" }
+        ]
+      }
+    }
+  ]
+});
+async function compile_types(nodes, file = "code.ts") {
+  const printer = ts27.createPrinter({ newLine: ts27.NewLineKind.LineFeed, omitTrailingSemicolon: true });
+  const printed = printer.printList(ts27.ListFormat.MultiLine, ts27.factory.createNodeArray(nodes), ts27.createSourceFile(file, "", ts27.ScriptTarget.Latest, false, ts27.ScriptKind.TS));
+  const results = await eslint.lintText(printed, { filePath: file });
+  if (results.length > 0) {
+    const result = results[0];
+    if (result.errorCount > 0 && !result.output) {
+      console.log(`[ESLint] ${file}: ${result.errorCount} errors`);
+      console.log("[ESLint] Sample messages:", result.messages.slice(0, 3));
+    }
+    if (result.output) {
+      return result.output;
+    }
+  }
+  return printed;
+}
+
+// src/typegen/import.ts
+import ts28 from "typescript";
+var { factory: factory26 } = ts28;
+function BindImports(module_path, modules, is_type_only = true) {
+  return factory26.createImportDeclaration(undefined, factory26.createImportClause(is_type_only, undefined, factory26.createNamedImports(modules.map((name) => factory26.createImportSpecifier(false, undefined, factory26.createIdentifier(name))))), factory26.createStringLiteral(module_path, true));
+}
+function handle_imports(imports) {
+  if (!imports)
+    return [];
+  const grouped = new Map;
+  for (const import_path of imports.ordered) {
+    const parts = import_path.split("::");
+    const type_name = parts.at(-1);
+    const path = parts.slice(0, -1);
+    let file;
+    if (path.length === 0) {
+      throw new Error(`[mcdoc_import] Import path has no module prefix: "${import_path}"`);
+    } else if (path[1] === "java") {
+      file = `sandstone/generated/${path.slice(2).join("/")}`;
+    } else if (path[0] === "sandstone") {
+      file = path.join("/");
+    } else {
+      throw new Error(`[mcdoc_import] Unsupported import location "${path[0]}" in "${import_path}"`);
+    }
+    const existing = grouped.get(file);
+    if (existing) {
+      existing.push(type_name);
+    } else {
+      grouped.set(file, [type_name]);
+    }
+  }
+  const declarations = [];
+  for (const [file, names] of grouped) {
+    if (file === "sandstone") {
+      const set_index = names.indexOf("Set");
+      if (set_index !== -1) {
+        names.splice(set_index, 1);
+        declarations.push(BindImports(file, ["Set"], false));
+      }
+      if (names.length === 0) {
+        continue;
+      }
+    }
+    declarations.push(BindImports(file, names));
+  }
+  return declarations;
+}
+
+// src/index.ts
+var cache_root = join(dirname(fileURLToPath(import.meta.url)), "cache");
+function registerAttributes(meta, release) {
+  mcdoc5.runtime.registerAttribute(meta, "since", mcdoc5.runtime.attribute.validator.string, {
+    filterElement: () => false
+  });
+  mcdoc5.runtime.registerAttribute(meta, "until", mcdoc5.runtime.attribute.validator.string, {
+    filterElement: () => true
+  });
+  mcdoc5.runtime.registerAttribute(meta, "deprecated", mcdoc5.runtime.attribute.validator.optional(mcdoc5.runtime.attribute.validator.string), {
+    mapField: (config, field, ctx) => {
+      if (config === undefined) {
+        return { ...field, deprecated: true };
+      }
+      if (!config.startsWith("1.")) {
+        ctx.logger.warn(`Invalid mcdoc attribute for "deprecated": ${config}`);
+        return field;
+      }
+      if (ReleaseVersion.cmp(release, config) >= 0) {
+        return { ...field, deprecated: true };
+      }
+      return field;
+    }
+  });
+}
+var mcdoc_raw = "";
+var vanillaMcdocUrl = "https://api.spyglassmc.com/vanilla-mcdoc/symbols";
+async function fetchVanillaMcdoc() {
+  try {
+    const buffer = await fetchWithCache(vanillaMcdocUrl);
+    mcdoc_raw = await buffer.text();
+    return JSON.parse(mcdoc_raw);
+  } catch (e) {
+    throw new Error(`Error occurred while fetching vanilla-mcdoc: ${errorMessage(e)}`);
+  }
+}
+async function fetchRegistries(versionId) {
+  console.debug(`[fetchRegistries] ${versionId}`);
+  let etag = "";
+  try {
+    const req = await fetchWithCache(`https://api.spyglassmc.com/mcje/versions/${versionId}/registries`);
+    etag = req.headers.get("ETag");
+    const data = await req.json();
+    const result = new Map;
+    for (const id in data) {
+      result.set(id, data[id].map((e) => "minecraft:" + e));
+    }
+    return [result, etag];
+  } catch (e) {
+    throw new Error(`Error occurred while fetching registries: ${errorMessage(e)}`);
+  }
+}
+async function fetchBlockStates(versionId) {
+  console.debug(`[fetchBlockStates] ${versionId}`);
+  const result = new Map;
+  let etag = "";
+  try {
+    const req = await fetchWithCache(`https://api.spyglassmc.com/mcje/versions/${versionId}/block_states`);
+    etag = req.headers.get("ETag");
+    const data = await req.json();
+    for (const id in data) {
+      result.set(id, data[id]);
+    }
+  } catch (e) {
+    console.warn("Error occurred while fetching block states:", errorMessage(e));
+  }
+  return [result, etag];
+}
+var VanillaMcdocUri = "mcdoc://vanilla-mcdoc/symbols.json";
+function vanillaMcdocRegistrar(vanillaMcdoc) {
+  return (symbols) => {
+    const start = performance.now();
+    for (const [id, typeDef] of Object.entries(vanillaMcdoc.mcdoc)) {
+      symbols.query(VanillaMcdocUri, "mcdoc", id).enter({
+        data: { data: { typeDef } },
+        usage: { type: "declaration" }
+      });
+    }
+    for (const [dispatcher, ids] of Object.entries(vanillaMcdoc["mcdoc/dispatcher"])) {
+      symbols.query(VanillaMcdocUri, "mcdoc/dispatcher", dispatcher).enter({ usage: { type: "declaration" } }).onEach(Object.entries(ids), ([id, typeDef], query) => {
+        query.member(id, (memberQuery) => {
+          memberQuery.enter({
+            data: { data: { typeDef } },
+            usage: { type: "declaration" }
+          });
+        });
+      });
+    }
+    const duration = performance.now() - start;
+    console.log(`[vanillaMcdocRegistrar] Done in ${duration}ms`);
+  };
+}
+var initialize2 = async (ctx) => {
+  const { config, logger, meta, externals, cacheRoot } = ctx;
+  const vanillaMcdoc = await fetchVanillaMcdoc();
+  meta.registerSymbolRegistrar("vanilla-mcdoc", {
+    checksum: vanillaMcdoc.ref,
+    registrar: vanillaMcdocRegistrar(vanillaMcdoc)
+  });
+  meta.registerUriBinder(je.binder.uriBinder);
+  const version = (await (await fetch("https://api.spyglassmc.com/mcje/versions")).json())[0];
+  const release = version.id;
+  const [registries, registriesETag] = await fetchRegistries(version.id);
+  const [blockStates, blockStatesETag] = await fetchBlockStates(version.id);
+  const summary = {
+    registries: Object.fromEntries(registries.entries()),
+    blocks: Object.fromEntries([...blockStates.entries()].map(([id, data]) => [id, data])),
+    fluids: je.dependency.Fluids,
+    commands: { type: "root", children: {} }
+  };
+  const versionETag = registriesETag + blockStatesETag;
+  meta.registerSymbolRegistrar("mcmeta-summary", {
+    checksum: versionETag,
+    registrar: je.dependency.symbolRegistrar(summary, release)
+  });
+  registerAttributes(meta, release);
+  return { loadedVersion: release };
+};
+async function generate(options = {}) {
+  const { out_dir = "types", tsconfig = true } = options;
+  const project_path = resolve(process.cwd(), "dummy");
+  await fileUtil.ensureDir(NodeJsExternals, project_path);
+  const service = new Service({
+    logger: {
+      log: (...log_args) => console.log(...log_args),
+      warn: (...log_args) => console.warn(...log_args),
+      error: (...log_args) => console.error(...log_args),
+      info: (...log_args) => console.info(...log_args)
+    },
+    project: {
+      cacheRoot: fileUtil.ensureEndingSlash(pathToFileURL(cache_root).toString()),
+      defaultConfig: ConfigService.merge(VanillaConfig, {
+        env: { dependencies: [] }
+      }),
+      externals: NodeJsExternals,
+      initializers: [mcdoc5.initialize, initialize2],
+      projectRoots: [fileUtil.ensureEndingSlash(pathToFileURL(project_path).toString())]
+    }
+  });
+  await service.project.ready();
+  await service.project.cacheService.save();
+  const type_gen = new TypesGenerator;
+  type_gen.resolve_types(service.project.symbols);
+  for await (const [symbol_path, { exports, imports }] of type_gen.resolved_symbols.entries()) {
+    const parts = symbol_path.split("::");
+    if (parts[0] === "") {
+      parts.shift();
+    }
+    const file = parts.slice(1);
+    file.unshift(out_dir);
+    const out_path = `${join(...file)}.ts`;
+    const code = await compile_types([
+      ...handle_imports(imports),
+      ...exports
+    ], out_path);
+    await Bun.write(out_path, code);
+  }
+  if (tsconfig) {
+    await Bun.write(join(out_dir, "tsconfig.json"), JSON.stringify({
+      compilerOptions: {
+        allowImportingTsExtensions: true,
+        noEmit: true,
+        baseUrl: "./",
+        paths: {
+          sandstone: ["../sandstone-types/index.ts"],
+          "sandstone/generated/*": [`./*`]
+        }
+      }
+    }, null, 2));
+  }
+  service.project.close();
+}
+export {
+  mcdoc_raw,
+  generate,
+  fetchVanillaMcdoc,
+  fetchRegistries,
+  fetchBlockStates
+};