redscript-mc 1.2.21 → 1.2.25

package/dist/typechecker/index.js

@@ -21,11 +21,21 @@ const ENTITY_HIERARCHY = {
     'Creeper': 'HostileMob',
     'Spider': 'HostileMob',
     'Enderman': 'HostileMob',
+    'Blaze': 'HostileMob',
+    'Witch': 'HostileMob',
+    'Slime': 'HostileMob',
+    'ZombieVillager': 'HostileMob',
+    'Husk': 'HostileMob',
+    'Drowned': 'HostileMob',
+    'Stray': 'HostileMob',
+    'WitherSkeleton': 'HostileMob',
+    'CaveSpider': 'HostileMob',
     'Pig': 'PassiveMob',
     'Cow': 'PassiveMob',
     'Sheep': 'PassiveMob',
     'Chicken': 'PassiveMob',
     'Villager': 'PassiveMob',
+    'WanderingTrader': 'PassiveMob',
     'ArmorStand': 'entity',
     'Item': 'entity',
     'Arrow': 'entity',
@@ -42,6 +52,24 @@ const MC_TYPE_TO_ENTITY = {
     'minecraft:spider': 'Spider',
     'enderman': 'Enderman',
     'minecraft:enderman': 'Enderman',
+    'blaze': 'Blaze',
+    'minecraft:blaze': 'Blaze',
+    'witch': 'Witch',
+    'minecraft:witch': 'Witch',
+    'slime': 'Slime',
+    'minecraft:slime': 'Slime',
+    'zombie_villager': 'ZombieVillager',
+    'minecraft:zombie_villager': 'ZombieVillager',
+    'husk': 'Husk',
+    'minecraft:husk': 'Husk',
+    'drowned': 'Drowned',
+    'minecraft:drowned': 'Drowned',
+    'stray': 'Stray',
+    'minecraft:stray': 'Stray',
+    'wither_skeleton': 'WitherSkeleton',
+    'minecraft:wither_skeleton': 'WitherSkeleton',
+    'cave_spider': 'CaveSpider',
+    'minecraft:cave_spider': 'CaveSpider',
     'pig': 'Pig',
     'minecraft:pig': 'Pig',
     'cow': 'Cow',
@@ -52,6 +80,8 @@ const MC_TYPE_TO_ENTITY = {
     'minecraft:chicken': 'Chicken',
     'villager': 'Villager',
     'minecraft:villager': 'Villager',
+    'wandering_trader': 'WanderingTrader',
+    'minecraft:wandering_trader': 'WanderingTrader',
     'armor_stand': 'ArmorStand',
     'minecraft:armor_stand': 'ArmorStand',
     'item': 'Item',

package/dist/types/entity-hierarchy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+export interface EntityTypeNode {
+    name: string;
+    mcId: string | null;
+    abstract: boolean;
+    parent: string | null;
+}
+export declare const ENTITY_TYPES: EntityTypeNode[];
+/** Map from lowercase name → EntityTypeNode */
+export declare const ENTITY_TYPE_MAP: Map<string, EntityTypeNode>;
+/** Map from mcId (without namespace) → EntityTypeNode */
+export declare const ENTITY_TYPE_BY_MCID: Map<string, EntityTypeNode>;
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+export declare function isSubtype(typeA: string, typeB: string): boolean;
+/** True if one type is a subtype of the other (in either direction) */
+export declare function areCompatibleTypes(outerType: string, innerType: string): boolean;
+/** Get all non-abstract leaf types under a given node */
+export declare function getConcreteSubtypes(typeName: string): EntityTypeNode[];
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+export declare function getSelectorEntityType(selector: string): string | null;
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+export declare function getBaseSelectorType(selector: string): string | null;

package/dist/types/entity-hierarchy.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Entity Type Hierarchy
+ *
+ * Closed inheritance tree mapping to Minecraft's entity registry.
+ * Used for type narrowing (is checks), selector<T> annotations,
+ * and W_IMPOSSIBLE_AS warnings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTITY_TYPE_BY_MCID = exports.ENTITY_TYPE_MAP = exports.ENTITY_TYPES = void 0;
+exports.isSubtype = isSubtype;
+exports.areCompatibleTypes = areCompatibleTypes;
+exports.getConcreteSubtypes = getConcreteSubtypes;
+exports.getSelectorEntityType = getSelectorEntityType;
+exports.getBaseSelectorType = getBaseSelectorType;
+exports.ENTITY_TYPES = [
+    // Root
+    { name: 'Entity', mcId: null, abstract: true, parent: null },
+    // Direct children of Entity
+    { name: 'Player', mcId: 'minecraft:player', abstract: false, parent: 'Entity' },
+    { name: 'ArmorStand', mcId: 'minecraft:armor_stand', abstract: false, parent: 'Entity' },
+    { name: 'Item', mcId: 'minecraft:item', abstract: false, parent: 'Entity' },
+    { name: 'Arrow', mcId: 'minecraft:arrow', abstract: false, parent: 'Entity' },
+    // Mob hierarchy
+    { name: 'Mob', mcId: null, abstract: true, parent: 'Entity' },
+    // Hostile mobs
+    { name: 'HostileMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Zombie', mcId: 'minecraft:zombie', abstract: false, parent: 'HostileMob' },
+    { name: 'Skeleton', mcId: 'minecraft:skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'Creeper', mcId: 'minecraft:creeper', abstract: false, parent: 'HostileMob' },
+    { name: 'Spider', mcId: 'minecraft:spider', abstract: false, parent: 'HostileMob' },
+    { name: 'Enderman', mcId: 'minecraft:enderman', abstract: false, parent: 'HostileMob' },
+    { name: 'Blaze', mcId: 'minecraft:blaze', abstract: false, parent: 'HostileMob' },
+    { name: 'Witch', mcId: 'minecraft:witch', abstract: false, parent: 'HostileMob' },
+    { name: 'Slime', mcId: 'minecraft:slime', abstract: false, parent: 'HostileMob' },
+    { name: 'ZombieVillager', mcId: 'minecraft:zombie_villager', abstract: false, parent: 'HostileMob' },
+    { name: 'Husk', mcId: 'minecraft:husk', abstract: false, parent: 'HostileMob' },
+    { name: 'Drowned', mcId: 'minecraft:drowned', abstract: false, parent: 'HostileMob' },
+    { name: 'Stray', mcId: 'minecraft:stray', abstract: false, parent: 'HostileMob' },
+    { name: 'WitherSkeleton', mcId: 'minecraft:wither_skeleton', abstract: false, parent: 'HostileMob' },
+    { name: 'CaveSpider', mcId: 'minecraft:cave_spider', abstract: false, parent: 'HostileMob' },
+    // Passive mobs
+    { name: 'PassiveMob', mcId: null, abstract: true, parent: 'Mob' },
+    { name: 'Pig', mcId: 'minecraft:pig', abstract: false, parent: 'PassiveMob' },
+    { name: 'Cow', mcId: 'minecraft:cow', abstract: false, parent: 'PassiveMob' },
+    { name: 'Sheep', mcId: 'minecraft:sheep', abstract: false, parent: 'PassiveMob' },
+    { name: 'Chicken', mcId: 'minecraft:chicken', abstract: false, parent: 'PassiveMob' },
+    { name: 'Villager', mcId: 'minecraft:villager', abstract: false, parent: 'PassiveMob' },
+    { name: 'WanderingTrader', mcId: 'minecraft:wandering_trader', abstract: false, parent: 'PassiveMob' },
+];
+/** Map from lowercase name → EntityTypeNode */
+exports.ENTITY_TYPE_MAP = new Map(exports.ENTITY_TYPES.map(t => [t.name.toLowerCase(), t]));
+/** Map from mcId (without namespace) → EntityTypeNode */
+exports.ENTITY_TYPE_BY_MCID = new Map(exports.ENTITY_TYPES
+    .filter(t => t.mcId !== null)
+    .map(t => [t.mcId.replace('minecraft:', ''), t]));
+/** Check if typeA is a subtype of typeB (recursive ancestry) */
+function isSubtype(typeA, typeB) {
+    if (typeA === typeB)
+        return true;
+    const node = exports.ENTITY_TYPE_MAP.get(typeA.toLowerCase());
+    if (!node || !node.parent)
+        return false;
+    return isSubtype(node.parent, typeB);
+}
+/** True if one type is a subtype of the other (in either direction) */
+function areCompatibleTypes(outerType, innerType) {
+    return isSubtype(outerType, innerType) || isSubtype(innerType, outerType);
+}
+/** Get all non-abstract leaf types under a given node */
+function getConcreteSubtypes(typeName) {
+    const results = [];
+    for (const node of exports.ENTITY_TYPES) {
+        if (!node.abstract && isSubtype(node.name, typeName)) {
+            results.push(node);
+        }
+    }
+    return results;
+}
+/** Parse "type=zombie" from a selector string, return the entity type name or null */
+function getSelectorEntityType(selector) {
+    const match = selector.match(/type=(?:minecraft:)?([a-z_]+)/);
+    if (!match)
+        return null;
+    const mcId = match[1];
+    const node = exports.ENTITY_TYPE_BY_MCID.get(mcId);
+    return node ? node.name : null;
+}
+/** Determine the base entity type from a selector kind:
+ *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
+function getBaseSelectorType(selector) {
+    const trimmed = selector.trim();
+    // Check for type filter first (works for any selector)
+    const typeFromFilter = getSelectorEntityType(trimmed);
+    if (trimmed.startsWith('@a') || trimmed.startsWith('@p') || trimmed.startsWith('@r')) {
+        return typeFromFilter ?? 'Player';
+    }
+    if (trimmed.startsWith('@e')) {
+        return typeFromFilter ?? 'Entity';
+    }
+    // @s — context-dependent, we don't know unless there's a type filter
+    if (trimmed.startsWith('@s')) {
+        return typeFromFilter ?? null;
+    }
+    return null;
+}
+//# sourceMappingURL=entity-hierarchy.js.map

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.0.12",
+  "version": "1.0.16",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.0.12",
+      "version": "1.0.16",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"
@@ -22,10 +22,12 @@
       }
     },
     "../..": {
-      "version": "0.1.0",
+      "name": "redscript-mc",
+      "version": "1.2.25",
       "license": "MIT",
       "bin": {
-        "redscript": "dist/cli.js"
+        "redscript": "dist/cli.js",
+        "rsc": "dist/cli.js"
       },
       "devDependencies": {
         "@types/jest": "^29.5.0",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.0.12",
+  "version": "1.0.16",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",
@@ -129,8 +129,8 @@
     "compile": "node build.mjs",
     "watch": "node build.mjs --watch",
     "build": "npm run compile",
-    "package": "npm run build && vsce package --no-dependencies",
-    "publish": "npm run build && vsce publish --no-dependencies"
+    "package": "npm run build && npx @vscode/vsce package --no-dependencies",
+    "publish": "npm run build && npx @vscode/vsce publish --no-dependencies"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.21",
+  "version": "1.2.25",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/entity-types.test.ts

@@ -0,0 +1,236 @@
+import {
+  isSubtype,
+  areCompatibleTypes,
+  getConcreteSubtypes,
+  getSelectorEntityType,
+  getBaseSelectorType,
+} from '../types/entity-hierarchy'
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { Lowering } from '../lowering'
+import type { IRModule } from '../ir/types'
+
+function compileWithWarnings(source: string, namespace = 'test'): { ir: IRModule; warnings: Lowering['warnings'] } {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse(namespace)
+  const lowering = new Lowering(namespace)
+  return { ir: lowering.lower(ast), warnings: lowering.warnings }
+}
+
+// ---------------------------------------------------------------------------
+// Entity hierarchy utilities
+// ---------------------------------------------------------------------------
+
+describe('Entity type hierarchy', () => {
+  test('isSubtype: Zombie is a subtype of Mob', () => {
+    expect(isSubtype('Zombie', 'Mob')).toBe(true)
+  })
+
+  test('isSubtype: Player is NOT a subtype of Mob', () => {
+    expect(isSubtype('Player', 'Mob')).toBe(false)
+  })
+
+  test('isSubtype: Zombie is a subtype of Entity (transitive)', () => {
+    expect(isSubtype('Zombie', 'Entity')).toBe(true)
+  })
+
+  test('isSubtype: identity — Zombie is subtype of Zombie', () => {
+    expect(isSubtype('Zombie', 'Zombie')).toBe(true)
+  })
+
+  test('areCompatibleTypes: Player and Zombie are NOT compatible', () => {
+    expect(areCompatibleTypes('Player', 'Zombie')).toBe(false)
+  })
+
+  test('areCompatibleTypes: Zombie and Mob are compatible', () => {
+    expect(areCompatibleTypes('Zombie', 'Mob')).toBe(true)
+  })
+
+  test('areCompatibleTypes: Mob and Zombie are compatible (reverse)', () => {
+    expect(areCompatibleTypes('Mob', 'Zombie')).toBe(true)
+  })
+
+  test('getConcreteSubtypes: HostileMob includes Zombie, Skeleton, Creeper', () => {
+    const subtypes = getConcreteSubtypes('HostileMob')
+    const names = subtypes.map(n => n.name)
+    expect(names).toContain('Zombie')
+    expect(names).toContain('Skeleton')
+    expect(names).toContain('Creeper')
+    expect(names).toContain('Blaze')
+    expect(names).toContain('CaveSpider')
+    // Should NOT include passive mobs
+    expect(names).not.toContain('Pig')
+    expect(names).not.toContain('Player')
+  })
+
+  test('getConcreteSubtypes: PassiveMob includes Pig, Cow, Villager', () => {
+    const subtypes = getConcreteSubtypes('PassiveMob')
+    const names = subtypes.map(n => n.name)
+    expect(names).toContain('Pig')
+    expect(names).toContain('Cow')
+    expect(names).toContain('Villager')
+    expect(names).toContain('WanderingTrader')
+    expect(names).not.toContain('Zombie')
+  })
+
+  test('getSelectorEntityType: parses type=zombie', () => {
+    expect(getSelectorEntityType('@e[type=zombie]')).toBe('Zombie')
+  })
+
+  test('getSelectorEntityType: parses type=minecraft:skeleton', () => {
+    expect(getSelectorEntityType('@e[type=minecraft:skeleton]')).toBe('Skeleton')
+  })
+
+  test('getBaseSelectorType: @a → Player', () => {
+    expect(getBaseSelectorType('@a')).toBe('Player')
+  })
+
+  test('getBaseSelectorType: @e → Entity', () => {
+    expect(getBaseSelectorType('@e')).toBe('Entity')
+  })
+
+  test('getBaseSelectorType: @e[type=zombie] → Zombie', () => {
+    expect(getBaseSelectorType('@e[type=zombie]')).toBe('Zombie')
+  })
+
+  test('getBaseSelectorType: @s → null', () => {
+    expect(getBaseSelectorType('@s')).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// W_IMPOSSIBLE_AS warning
+// ---------------------------------------------------------------------------
+
+describe('W_IMPOSSIBLE_AS warning', () => {
+  test('foreach @a with as @e[type=zombie] produces warning', () => {
+    const source = `
+      fn main() {
+        foreach (p in @a) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `
+    const { warnings } = compileWithWarnings(source)
+    const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS')
+    expect(impossible.length).toBe(1)
+    expect(impossible[0].message).toContain('Player')
+    expect(impossible[0].message).toContain('Zombie')
+  })
+
+  test('foreach @e[type=zombie] with as @e[type=zombie] produces NO warning', () => {
+    const source = `
+      fn main() {
+        foreach (z in @e[type=minecraft:zombie]) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `
+    const { warnings } = compileWithWarnings(source)
+    const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS')
+    expect(impossible.length).toBe(0)
+  })
+
+  test('foreach @e (generic) with as @e[type=zombie] produces NO warning', () => {
+    const source = `
+      fn main() {
+        foreach (e in @e) {
+          as @e[type=minecraft:zombie] {
+            kill(@s);
+          }
+        }
+      }
+    `
+    const { warnings } = compileWithWarnings(source)
+    const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS')
+    expect(impossible.length).toBe(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// is_check with abstract types
+// ---------------------------------------------------------------------------
+
+describe('is_check compilation', () => {
+  test('concrete is_check emits single execute if entity', () => {
+    const source = `
+      fn main() {
+        foreach (e in @e) {
+          if (e is Zombie) {
+            kill(@s);
+          }
+        }
+      }
+    `
+    const { ir } = compileWithWarnings(source)
+    const thenFn = ir.functions.find(f => f.name.includes('then_'))
+    expect(thenFn).toBeDefined()
+
+    // The parent foreach function should contain the execute if entity command
+    const foreachFn = ir.functions.find(f => f.name.includes('foreach_'))
+    expect(foreachFn).toBeDefined()
+    const rawCmds = foreachFn!.blocks.flatMap(b => b.instrs)
+      .filter((i): i is any => i.op === 'raw')
+      .map(i => i.cmd)
+    expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true)
+  })
+
+  test('abstract is_check (HostileMob) emits multiple type checks', () => {
+    const source = `
+      fn main() {
+        foreach (e in @e) {
+          if (e is HostileMob) {
+            kill(@s);
+          }
+        }
+      }
+    `
+    const { ir } = compileWithWarnings(source)
+    const foreachFn = ir.functions.find(f => f.name.includes('foreach_'))
+    expect(foreachFn).toBeDefined()
+    const rawCmds = foreachFn!.blocks.flatMap(b => b.instrs)
+      .filter((i): i is any => i.op === 'raw')
+      .map(i => i.cmd)
+
+    // Should have scoreboard setup and multiple type checks
+    expect(rawCmds.some(c => c.includes('scoreboard players set __is_result rs:temp 0'))).toBe(true)
+    expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true)
+    expect(rawCmds.some(c => c.includes('type=minecraft:skeleton'))).toBe(true)
+    expect(rawCmds.some(c => c.includes('type=minecraft:creeper'))).toBe(true)
+    expect(rawCmds.some(c => c.includes('if score __is_result rs:temp matches 1'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// selector<T> type annotation
+// ---------------------------------------------------------------------------
+
+describe('selector<T> type annotation', () => {
+  test('parses selector<Player> type', () => {
+    const source = `
+      fn greet(target: selector<Player>) {
+        say("hello");
+      }
+    `
+    const tokens = new Lexer(source).tokenize()
+    const ast = new Parser(tokens).parse('test')
+    const fn = ast.declarations[0]
+    expect(fn.params[0].type).toEqual({ kind: 'selector', entityType: 'Player' })
+  })
+
+  test('parses plain selector type', () => {
+    const source = `
+      fn greet(target: selector) {
+        say("hello");
+      }
+    `
+    const tokens = new Lexer(source).tokenize()
+    const ast = new Parser(tokens).parse('test')
+    const fn = ast.declarations[0]
+    expect(fn.params[0].type).toEqual({ kind: 'selector' })
+  })
+})

package/src/__tests__/var-allocator.test.ts

@@ -0,0 +1,75 @@
+import { VarAllocator } from '../codegen/var-allocator'
+
+describe('VarAllocator', () => {
+  describe('mangle mode (default)', () => {
+    it('generates sequential names: a, b, ..., z, aa, ab', () => {
+      const alloc = new VarAllocator(true)
+      const names: string[] = []
+      for (let i = 0; i < 28; i++) {
+        names.push(alloc.alloc(`var${i}`))
+      }
+      expect(names[0]).toBe('$a')
+      expect(names[1]).toBe('$b')
+      expect(names[25]).toBe('$z')
+      expect(names[26]).toBe('$aa')
+      expect(names[27]).toBe('$ab')
+    })
+
+    it('caches: same name returns same result', () => {
+      const alloc = new VarAllocator(true)
+      const first = alloc.alloc('x')
+      const second = alloc.alloc('x')
+      expect(first).toBe(second)
+    })
+
+    it('constant() is content-addressed: same value returns same result', () => {
+      const alloc = new VarAllocator(true)
+      const first = alloc.constant(42)
+      const second = alloc.constant(42)
+      expect(first).toBe(second)
+    })
+
+    it('different variables get different names', () => {
+      const alloc = new VarAllocator(true)
+      const a = alloc.alloc('foo')
+      const b = alloc.alloc('bar')
+      expect(a).not.toBe(b)
+    })
+
+    it('alloc, constant, and internal share the same sequential pool', () => {
+      const alloc = new VarAllocator(true)
+      const v = alloc.alloc('x')       // $a
+      const c = alloc.constant(1)       // $b
+      const i = alloc.internal('ret')   // $c
+      expect(v).toBe('$a')
+      expect(c).toBe('$b')
+      expect(i).toBe('$c')
+    })
+
+    it('strips $ prefix from variable names', () => {
+      const alloc = new VarAllocator(true)
+      const a = alloc.alloc('$foo')
+      const b = alloc.alloc('foo')
+      expect(a).toBe(b) // same underlying name
+    })
+  })
+
+  describe('no-mangle mode', () => {
+    it('uses $<name> for user vars', () => {
+      const alloc = new VarAllocator(false)
+      expect(alloc.alloc('counter')).toBe('$counter')
+    })
+
+    it('uses $const_<value> for constants', () => {
+      const alloc = new VarAllocator(false)
+      expect(alloc.constant(10)).toBe('$const_10')
+      expect(alloc.constant(-3)).toBe('$const_-3')
+    })
+
+    it('uses $<suffix> for internals', () => {
+      const alloc = new VarAllocator(false)
+      expect(alloc.internal('ret')).toBe('$ret')
+      expect(alloc.internal('p0')).toBe('$p0')
+    })
+  })
+})

package/src/ast/types.ts

@@ -25,15 +25,19 @@ export interface Span {
 export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string'
 
 // Entity type hierarchy
-export type EntityTypeName = 
+export type EntityTypeName =
   | 'entity'      // Base type
   | 'Player'      // @a, @p, @r
   | 'Mob'         // Base mob type
   | 'HostileMob'  // Hostile mobs
   | 'PassiveMob'  // Passive mobs
-  // Specific mob types (common ones)
+  // Hostile mob types
   | 'Zombie' | 'Skeleton' | 'Creeper' | 'Spider' | 'Enderman'
-  | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager'
+  | 'Blaze' | 'Witch' | 'Slime' | 'ZombieVillager' | 'Husk'
+  | 'Drowned' | 'Stray' | 'WitherSkeleton' | 'CaveSpider'
+  // Passive mob types
+  | 'Pig' | 'Cow' | 'Sheep' | 'Chicken' | 'Villager' | 'WanderingTrader'
+  // Non-mob entities
   | 'ArmorStand' | 'Item' | 'Arrow'
 
 export type TypeNode =
@@ -43,7 +47,7 @@ export type TypeNode =
   | { kind: 'enum'; name: string }
   | { kind: 'function_type'; params: TypeNode[]; return: TypeNode }
   | { kind: 'entity'; entityType: EntityTypeName }  // Entity types
-  | { kind: 'selector' }  // Selector type (multiple entities)
+  | { kind: 'selector'; entityType?: string }  // Selector type, optionally parameterized: selector<Player>
 
 export interface LambdaParam {
   name: string