redscript-mc 1.2.21 → 1.2.25

package/dist/codegen/mcfunction/index.js

@@ -22,24 +22,18 @@ exports.generateDatapackWithStats = generateDatapackWithStats;
 exports.generateDatapack = generateDatapack;
 const commands_1 = require("../../optimizer/commands");
 const types_1 = require("../../events/types");
+const var_allocator_1 = require("../var-allocator");
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
 const OBJ = 'rs'; // scoreboard objective name
-function varRef(name) {
-    // Ensure fake player prefix
-    return name.startsWith('$') ? name : `$${name}`;
-}
-function operandToScore(op) {
+function operandToScore(op, alloc) {
     if (op.kind === 'var')
-        return `${varRef(op.name)} ${OBJ}`;
+        return `${alloc.alloc(op.name)} ${OBJ}`;
     if (op.kind === 'const')
-        return `$const_${op.value} ${OBJ}`;
+        return `${alloc.constant(op.value)} ${OBJ}`;
     throw new Error(`Cannot convert storage operand to score: ${op.path}`);
 }
-function constSetup(value) {
-    return `scoreboard players set $const_${value} ${OBJ} ${value}`;
-}
 // Collect all constants used in a function for pre-setup
 function collectConsts(fn) {
     const consts = new Set();
@@ -73,17 +67,17 @@ const BOP_OP = {
 // ---------------------------------------------------------------------------
 // Instruction codegen
 // ---------------------------------------------------------------------------
-function emitInstr(instr, ns) {
+function emitInstr(instr, ns, alloc) {
     const lines = [];
     switch (instr.op) {
         case 'assign': {
-            const dst = varRef(instr.dst);
+            const dst = alloc.alloc(instr.dst);
             const src = instr.src;
             if (src.kind === 'const') {
                 lines.push(`scoreboard players set ${dst} ${OBJ} ${src.value}`);
             }
             else if (src.kind === 'var') {
-                lines.push(`scoreboard players operation ${dst} ${OBJ} = ${varRef(src.name)} ${OBJ}`);
+                lines.push(`scoreboard players operation ${dst} ${OBJ} = ${alloc.alloc(src.name)} ${OBJ}`);
             }
             else {
                 lines.push(`execute store result score ${dst} ${OBJ} run data get storage ${src.path}`);
@@ -91,18 +85,18 @@ function emitInstr(instr, ns) {
             break;
         }
         case 'binop': {
-            const dst = varRef(instr.dst);
+            const dst = alloc.alloc(instr.dst);
             const bop = BOP_OP[instr.bop] ?? '+=';
             // Copy lhs → dst, then apply op with rhs
-            lines.push(...emitInstr({ op: 'assign', dst: instr.dst, src: instr.lhs }, ns));
-            lines.push(`scoreboard players operation ${dst} ${OBJ} ${bop} ${operandToScore(instr.rhs)}`);
+            lines.push(...emitInstr({ op: 'assign', dst: instr.dst, src: instr.lhs }, ns, alloc));
+            lines.push(`scoreboard players operation ${dst} ${OBJ} ${bop} ${operandToScore(instr.rhs, alloc)}`);
             break;
         }
         case 'cmp': {
             // MC doesn't have a direct compare-to-register; use execute store
-            const dst = varRef(instr.dst);
-            const lhsScore = operandToScore(instr.lhs);
-            const rhsScore = operandToScore(instr.rhs);
+            const dst = alloc.alloc(instr.dst);
+            const lhsScore = operandToScore(instr.lhs, alloc);
+            const rhsScore = operandToScore(instr.rhs, alloc);
             lines.push(`scoreboard players set ${dst} ${OBJ} 0`);
             switch (instr.cop) {
                 case '==':
@@ -127,13 +121,15 @@ function emitInstr(instr, ns) {
             break;
         }
         case 'call': {
-            // Push args as fake players $p0, $p1, ...
+            // Push args as param fake players
             for (let i = 0; i < instr.args.length; i++) {
-                lines.push(...emitInstr({ op: 'assign', dst: `$p${i}`, src: instr.args[i] }, ns));
+                const paramName = alloc.internal(`p${i}`);
+                lines.push(...emitInstr({ op: 'assign', dst: paramName, src: instr.args[i] }, ns, alloc));
             }
             lines.push(`function ${ns}:${instr.fn}`);
             if (instr.dst) {
-                lines.push(`scoreboard players operation ${varRef(instr.dst)} ${OBJ} = $ret ${OBJ}`);
+                const retName = alloc.internal('ret');
+                lines.push(`scoreboard players operation ${alloc.alloc(instr.dst)} ${OBJ} = ${retName} ${OBJ}`);
             }
             break;
         }
@@ -146,32 +142,34 @@ function emitInstr(instr, ns) {
 // ---------------------------------------------------------------------------
 // Terminator codegen
 // ---------------------------------------------------------------------------
-function emitTerm(term, ns, fnName) {
+function emitTerm(term, ns, fnName, alloc) {
     const lines = [];
     switch (term.op) {
         case 'jump':
             lines.push(`function ${ns}:${fnName}/${term.target}`);
             break;
         case 'jump_if':
-            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.then}`);
-            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.else_}`);
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.then}`);
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.else_}`);
             break;
         case 'jump_unless':
-            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.then}`);
-            lines.push(`execute if score ${varRef(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.else_}`);
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches ..0 run function ${ns}:${fnName}/${term.then}`);
+            lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.else_}`);
             break;
-        case 'return':
+        case 'return': {
+            const retName = alloc.internal('ret');
             if (term.value) {
-                lines.push(...emitInstr({ op: 'assign', dst: '$ret', src: term.value }, ns));
+                lines.push(...emitInstr({ op: 'assign', dst: retName, src: term.value }, ns, alloc));
             }
             // In MC 1.20+, use `return` command
             if (term.value?.kind === 'const') {
                 lines.push(`return ${term.value.value}`);
             }
             else if (term.value?.kind === 'var') {
-                lines.push(`return run scoreboard players get ${varRef(term.value.name)} ${OBJ}`);
+                lines.push(`return run scoreboard players get ${alloc.alloc(term.value.name)} ${OBJ}`);
             }
             break;
+        }
         case 'tick_yield':
             lines.push(`schedule function ${ns}:${fnName}/${term.continuation} 1t replace`);
             break;
@@ -240,7 +238,8 @@ function countMcfunctionCommands(files) {
     }, 0);
 }
 function generateDatapackWithStats(module, options = {}) {
-    const { optimizeCommands = true } = options;
+    const { optimizeCommands = true, mangle = false } = options;
+    const alloc = new var_allocator_1.VarAllocator(mangle);
     const files = [];
     const advancements = [];
     const ns = module.namespace;
@@ -269,7 +268,7 @@ function generateDatapackWithStats(module, options = {}) {
         `scoreboard objectives add ${OBJ} dummy`,
     ];
     for (const g of module.globals) {
-        loadLines.push(`scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`);
+        loadLines.push(`scoreboard players set ${alloc.alloc(g.name)} ${OBJ} ${g.init}`);
     }
     // Add trigger objectives
     for (const triggerName of triggerNames) {
@@ -308,13 +307,17 @@ function generateDatapackWithStats(module, options = {}) {
             content: dispatchLines.join('\n'),
         });
     }
-    // Generate each function (and collect constants for load)
+    // Collect all constants across all functions first (deduplicated)
+    const allConsts = new Set();
+    for (const fn of module.functions) {
+        for (const c of collectConsts(fn))
+            allConsts.add(c);
+    }
+    if (allConsts.size > 0) {
+        loadLines.push(...Array.from(allConsts).sort((a, b) => a - b).map(value => `scoreboard players set ${alloc.constant(value)} ${OBJ} ${value}`));
+    }
+    // Generate each function
     for (const fn of module.functions) {
-        // Constant setup — place constants in __load.mcfunction
-        const consts = collectConsts(fn);
-        if (consts.size > 0) {
-            loadLines.push(...Array.from(consts).map(constSetup));
-        }
         // Entry block → <fn_name>.mcfunction
         // Continuation blocks → <fn_name>/<label>.mcfunction
         for (let i = 0; i < fn.blocks.length; i++) {
@@ -323,16 +326,21 @@ function generateDatapackWithStats(module, options = {}) {
             // Param setup in entry block
             if (i === 0) {
                 for (let j = 0; j < fn.params.length; j++) {
-                    lines.push(`scoreboard players operation ${varRef(fn.params[j])} ${OBJ} = $p${j} ${OBJ}`);
+                    lines.push(`scoreboard players operation ${alloc.alloc(fn.params[j])} ${OBJ} = ${alloc.internal(`p${j}`)} ${OBJ}`);
                 }
             }
             for (const instr of block.instrs) {
-                lines.push(...emitInstr(instr, ns));
+                lines.push(...emitInstr(instr, ns, alloc));
             }
-            lines.push(...emitTerm(block.term, ns, fn.name));
+            lines.push(...emitTerm(block.term, ns, fn.name, alloc));
             const filePath = i === 0
                 ? `data/${ns}/function/${fn.name}.mcfunction`
                 : `data/${ns}/function/${fn.name}/${block.label}.mcfunction`;
+            // Skip empty continuation blocks (only contain the block comment, no real commands)
+            // Entry block (i === 0) is always emitted so the function file exists
+            const hasRealContent = lines.some(l => !l.startsWith('#') && l.trim() !== '');
+            if (i !== 0 && !hasRealContent)
+                continue;
             files.push({ path: filePath, content: lines.join('\n') });
         }
     }
@@ -442,12 +450,13 @@ function generateDatapackWithStats(module, options = {}) {
         });
     }
     const stats = (0, commands_1.createEmptyOptimizationStats)();
+    const sourceMap = mangle ? alloc.toSourceMap() : undefined;
     if (!optimizeCommands) {
-        return { files, advancements, stats };
+        return { files, advancements, stats, sourceMap };
     }
     const optimized = applyFunctionOptimization(files);
     (0, commands_1.mergeOptimizationStats)(stats, optimized.stats);
-    return { files: optimized.files, advancements, stats };
+    return { files: optimized.files, advancements, stats, sourceMap };
 }
 function generateDatapack(module) {
     const generated = generateDatapackWithStats(module);

package/dist/codegen/structure/index.d.ts

@@ -16,6 +16,9 @@ export interface StructureCompileResult {
 }
 export interface StructureCompileOptions {
     dce?: boolean;
+    mangle?: boolean;
 }
-export declare function generateStructure(input: IRModule | DatapackFile[]): StructureCompileResult;
+export declare function generateStructure(input: IRModule | DatapackFile[], options?: {
+    mangle?: boolean;
+}): StructureCompileResult;
 export declare function compileToStructure(source: string, namespace: string, filePath?: string, options?: StructureCompileOptions): StructureCompileResult;

package/dist/codegen/structure/index.js

@@ -12,6 +12,7 @@ const structure_1 = require("../../optimizer/structure");
 const dce_1 = require("../../optimizer/dce");
 const compile_1 = require("../../compile");
 const types_1 = require("../../events/types");
+const var_allocator_1 = require("../var-allocator");
 const DATA_VERSION = 3953;
 const MAX_WIDTH = 16;
 const OBJ = 'rs';
@@ -29,9 +30,6 @@ const palette = [
 function escapeJsonString(value) {
     return JSON.stringify(value).slice(1, -1);
 }
-function varRef(name) {
-    return name.startsWith('$') ? name : `$${name}`;
-}
 function collectConsts(fn) {
     const consts = new Set();
     for (const block of fn.blocks) {
@@ -57,10 +55,8 @@ function collectConsts(fn) {
     }
     return consts;
 }
-function constSetup(value) {
-    return `scoreboard players set $const_${value} ${OBJ} ${value}`;
-}
-function collectCommandEntriesFromModule(module) {
+function collectCommandEntriesFromModule(module, mangle = false) {
+    const alloc = new var_allocator_1.VarAllocator(mangle);
     const entries = [];
     const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
     const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
@@ -68,12 +64,12 @@ function collectCommandEntriesFromModule(module) {
     const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
     const loadCommands = [
         `scoreboard objectives add ${OBJ} dummy`,
-        ...module.globals.map(g => `scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`),
+        ...module.globals.map(g => `scoreboard players set ${alloc.alloc(g.name)} ${OBJ} ${g.init}`),
         ...Array.from(triggerNames).flatMap(triggerName => [
             `scoreboard objectives add ${triggerName} trigger`,
             `scoreboard players enable @a ${triggerName}`,
         ]),
-        ...Array.from(new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))).map(constSetup),
+        ...Array.from(new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))).map(value => `scoreboard players set ${alloc.constant(value)} ${OBJ} ${value}`),
     ];
     for (const eventType of eventTypes) {
         if (eventType === 'PlayerDeath') {
@@ -229,10 +225,10 @@ function createBlockTag(entry, index) {
         nbt: createBlockEntityTag(entry),
     });
 }
-function generateStructure(input) {
+function generateStructure(input, options) {
     const entries = Array.isArray(input)
         ? collectCommandEntriesFromFiles(input)
-        : collectCommandEntriesFromModule(input);
+        : collectCommandEntriesFromModule(input, options?.mangle);
     const blockTags = entries.map(createBlockTag);
     const sizeX = Math.max(1, Math.min(MAX_WIDTH, entries.length || 1));
     const sizeZ = Math.max(1, Math.min(MAX_WIDTH, Math.ceil(entries.length / MAX_WIDTH) || 1));
@@ -276,7 +272,7 @@ function compileToStructure(source, namespace, filePath, options = {}) {
         functions: structureOptimized.functions,
     };
     return {
-        ...generateStructure(optimizedModule),
+        ...generateStructure(optimizedModule, { mangle: options.mangle }),
         stats,
     };
 }

package/dist/codegen/var-allocator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * VarAllocator — assigns scoreboard fake-player names to variables.
+ *
+ * mangle=true:  sequential short names ($a, $b, ..., $z, $aa, $ab, ...)
+ * mangle=false: legacy names ($<name> for vars, $const_<v> for consts, $p0/$ret for internals)
+ */
+export declare class VarAllocator {
+    private readonly mangle;
+    private seq;
+    private readonly varCache;
+    private readonly constCache;
+    private readonly internalCache;
+    constructor(mangle?: boolean);
+    /** Allocate a name for a user variable. Strips leading '$' if present. */
+    alloc(originalName: string): string;
+    /** Allocate a name for a constant value (content-addressed). */
+    constant(value: number): string;
+    /** Allocate a name for a compiler internal (e.g. "ret", "p0"). */
+    internal(suffix: string): string;
+    /** Generate the next sequential name: a, b, ..., z, aa, ab, ..., az, ba, ... */
+    private nextSeqName;
+    /**
+     * Returns a sourcemap object mapping allocated name → original name.
+     * Useful for debugging: write to <output>.map.json alongside the datapack.
+     * Only meaningful when mangle=true.
+     */
+    toSourceMap(): Record<string, string>;
+}

package/dist/codegen/var-allocator.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * VarAllocator — assigns scoreboard fake-player names to variables.
+ *
+ * mangle=true:  sequential short names ($a, $b, ..., $z, $aa, $ab, ...)
+ * mangle=false: legacy names ($<name> for vars, $const_<v> for consts, $p0/$ret for internals)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VarAllocator = void 0;
+class VarAllocator {
+    constructor(mangle = true) {
+        this.seq = 0;
+        this.varCache = new Map();
+        this.constCache = new Map();
+        this.internalCache = new Map();
+        this.mangle = mangle;
+    }
+    /** Allocate a name for a user variable. Strips leading '$' if present. */
+    alloc(originalName) {
+        const clean = originalName.startsWith('$') ? originalName.slice(1) : originalName;
+        const cached = this.varCache.get(clean);
+        if (cached)
+            return cached;
+        const name = this.mangle ? `$${this.nextSeqName()}` : `$${clean}`;
+        this.varCache.set(clean, name);
+        return name;
+    }
+    /** Allocate a name for a constant value (content-addressed). */
+    constant(value) {
+        const cached = this.constCache.get(value);
+        if (cached)
+            return cached;
+        const name = this.mangle ? `$${this.nextSeqName()}` : `$const_${value}`;
+        this.constCache.set(value, name);
+        return name;
+    }
+    /** Allocate a name for a compiler internal (e.g. "ret", "p0"). */
+    internal(suffix) {
+        const cached = this.internalCache.get(suffix);
+        if (cached)
+            return cached;
+        const name = this.mangle ? `$${this.nextSeqName()}` : `$${suffix}`;
+        this.internalCache.set(suffix, name);
+        return name;
+    }
+    /** Generate the next sequential name: a, b, ..., z, aa, ab, ..., az, ba, ... */
+    nextSeqName() {
+        const n = this.seq++;
+        let result = '';
+        let remaining = n;
+        do {
+            result = String.fromCharCode(97 + (remaining % 26)) + result;
+            remaining = Math.floor(remaining / 26) - 1;
+        } while (remaining >= 0);
+        return result;
+    }
+    /**
+     * Returns a sourcemap object mapping allocated name → original name.
+     * Useful for debugging: write to <output>.map.json alongside the datapack.
+     * Only meaningful when mangle=true.
+     */
+    toSourceMap() {
+        const map = {};
+        for (const [orig, alloc] of this.varCache) {
+            // Skip compiler-generated temporaries (start with _ followed by digits)
+            if (/^_\d+$/.test(orig))
+                continue;
+            map[alloc] = orig;
+        }
+        for (const [val, alloc] of this.constCache)
+            map[alloc] = `const:${val}`;
+        for (const [suf, alloc] of this.internalCache)
+            map[alloc] = `internal:${suf}`;
+        return map;
+    }
+}
+exports.VarAllocator = VarAllocator;
+//# sourceMappingURL=var-allocator.js.map

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export interface CompileOptions {
     typeCheck?: boolean;
     filePath?: string;
     dce?: boolean;
+    mangle?: boolean;
 }
 export interface CompileResult {
     files: DatapackFile[];
@@ -25,6 +26,7 @@ export interface CompileResult {
     typeErrors?: DiagnosticError[];
     warnings?: Warning[];
     stats?: OptimizationStats;
+    sourceMap?: Record<string, string>;
 }
 /**
  * Compile RedScript source code to a Minecraft datapack.

package/dist/index.js

@@ -31,6 +31,7 @@ function compile(source, options = {}) {
     const shouldOptimize = options.optimize ?? true;
     const shouldTypeCheck = options.typeCheck ?? true;
     const shouldRunDce = options.dce ?? shouldOptimize;
+    const mangle = options.mangle ?? false;
     const filePath = options.filePath;
     const preprocessed = (0, compile_1.preprocessSourceWithMetadata)(source, { filePath });
     const preprocessedSource = preprocessed.source;
@@ -50,7 +51,7 @@ function compile(source, options = {}) {
     const lowering = new lowering_1.Lowering(namespace, preprocessed.ranges);
     const ir = lowering.lower(ast);
     let optimizedIR = ir;
-    let generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: shouldOptimize });
+    let generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: shouldOptimize, mangle });
     let optimizationStats;
     if (shouldOptimize) {
         const stats = (0, commands_1.createEmptyOptimizationStats)();
@@ -66,10 +67,10 @@ function compile(source, options = {}) {
         }
         const copyPropagatedIR = { ...ir, functions: copyPropagatedFunctions };
         optimizedIR = { ...ir, functions: deadCodeEliminatedFunctions };
-        const baselineGenerated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: false });
-        const beforeDceGenerated = (0, mcfunction_1.generateDatapackWithStats)(copyPropagatedIR, { optimizeCommands: false });
-        const afterDceGenerated = (0, mcfunction_1.generateDatapackWithStats)(optimizedIR, { optimizeCommands: false });
-        generated = (0, mcfunction_1.generateDatapackWithStats)(optimizedIR, { optimizeCommands: true });
+        const baselineGenerated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: false, mangle });
+        const beforeDceGenerated = (0, mcfunction_1.generateDatapackWithStats)(copyPropagatedIR, { optimizeCommands: false, mangle });
+        const afterDceGenerated = (0, mcfunction_1.generateDatapackWithStats)(optimizedIR, { optimizeCommands: false, mangle });
+        generated = (0, mcfunction_1.generateDatapackWithStats)(optimizedIR, { optimizeCommands: true, mangle });
         stats.deadCodeRemoved =
             (0, mcfunction_1.countMcfunctionCommands)(beforeDceGenerated.files) - (0, mcfunction_1.countMcfunctionCommands)(afterDceGenerated.files);
         stats.licmHoists = generated.stats.licmHoists;
@@ -85,7 +86,7 @@ function compile(source, options = {}) {
     }
     else {
         optimizedIR = ir;
-        generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: false });
+        generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: false, mangle });
     }
     return {
         files: [...generated.files, ...generated.advancements],
@@ -95,6 +96,7 @@ function compile(source, options = {}) {
         typeErrors,
         warnings: [...dceResult.warnings, ...lowering.warnings],
         stats: optimizationStats,
+        sourceMap: generated.sourceMap,
     };
 }
 /**

package/dist/lowering/index.d.ts

@@ -29,6 +29,8 @@ export declare class Lowering {
     private timeoutCounter;
     private intervalCounter;
     readonly warnings: Warning[];
+    private entityContextStack;
+    private currentEntityContext;
     private builder;
     private varMap;
     private lambdaBindings;

package/dist/lowering/index.js

@@ -44,6 +44,7 @@ const builder_1 = require("../ir/builder");
 const diagnostics_1 = require("../diagnostics");
 const path = __importStar(require("path"));
 const types_1 = require("../events/types");
+const entity_hierarchy_1 = require("../types/entity-hierarchy");
 // ---------------------------------------------------------------------------
 // Macro-aware builtins (MC 1.20.2+)
 // These builtins generate commands where parameter variables cannot appear
@@ -140,11 +141,21 @@ const ENTITY_TO_MC_TYPE = {
     Creeper: 'minecraft:creeper',
     Spider: 'minecraft:spider',
     Enderman: 'minecraft:enderman',
+    Blaze: 'minecraft:blaze',
+    Witch: 'minecraft:witch',
+    Slime: 'minecraft:slime',
+    ZombieVillager: 'minecraft:zombie_villager',
+    Husk: 'minecraft:husk',
+    Drowned: 'minecraft:drowned',
+    Stray: 'minecraft:stray',
+    WitherSkeleton: 'minecraft:wither_skeleton',
+    CaveSpider: 'minecraft:cave_spider',
     Pig: 'minecraft:pig',
     Cow: 'minecraft:cow',
     Sheep: 'minecraft:sheep',
     Chicken: 'minecraft:chicken',
     Villager: 'minecraft:villager',
+    WanderingTrader: 'minecraft:wandering_trader',
     ArmorStand: 'minecraft:armor_stand',
     Item: 'minecraft:item',
     Arrow: 'minecraft:arrow',
@@ -185,6 +196,11 @@ function emitBlockPos(pos) {
 // Lowering Class
 // ---------------------------------------------------------------------------
 class Lowering {
+    currentEntityContext() {
+        return this.entityContextStack.length > 0
+            ? this.entityContextStack[this.entityContextStack.length - 1]
+            : 'Entity';
+    }
     constructor(namespace, sourceRanges = []) {
         this.functions = [];
         this.globals = [];
@@ -198,6 +214,8 @@ class Lowering {
         this.timeoutCounter = 0;
         this.intervalCounter = 0;
         this.warnings = [];
+        // Entity type context stack for W_IMPOSSIBLE_AS warnings
+        this.entityContextStack = [];
         this.varMap = new Map();
         this.lambdaBindings = new Map();
         this.intervalBindings = new Map();
@@ -938,11 +956,26 @@ class Lowering {
             throw new diagnostics_1.DiagnosticError('LoweringError', "'is' checks require an entity selector or entity binding", cond.span ?? stmt.span ?? { line: 0, col: 0 });
         }
         const mcType = ENTITY_TO_MC_TYPE[cond.entityType];
+        const thenFnName = `${this.currentFn}/then_${this.foreachCounter++}`;
         if (!mcType) {
-            throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot lower entity type check for '${cond.entityType}'`, cond.span ?? stmt.span ?? { line: 0, col: 0 });
+            // Abstract type — check all concrete subtypes
+            const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)(cond.entityType);
+            if (subtypes.length === 0) {
+                throw new diagnostics_1.DiagnosticError('LoweringError', `Cannot lower entity type check for '${cond.entityType}'`, cond.span ?? stmt.span ?? { line: 0, col: 0 });
+            }
+            // Use a temp scoreboard variable to OR multiple type checks
+            this.builder.emitRaw(`scoreboard players set __is_result rs:temp 0`);
+            for (const subtype of subtypes) {
+                if (subtype.mcId) {
+                    this.builder.emitRaw(`execute if entity ${this.appendTypeFilter(selector, subtype.mcId)} run scoreboard players set __is_result rs:temp 1`);
+                }
+            }
+            this.builder.emitRaw(`execute if score __is_result rs:temp matches 1 run function ${this.namespace}:${thenFnName}`);
+        }
+        else {
+            // Concrete type — single check
+            this.builder.emitRaw(`execute if entity ${this.appendTypeFilter(selector, mcType)} run function ${this.namespace}:${thenFnName}`);
         }
-        const thenFnName = `${this.currentFn}/then_${this.foreachCounter++}`;
-        this.builder.emitRaw(`execute if entity ${this.appendTypeFilter(selector, mcType)} run function ${this.namespace}:${thenFnName}`);
         const savedBuilder = this.builder;
         const savedVarMap = new Map(this.varMap);
         const savedBlockPosVars = new Map(this.blockPosVars);
@@ -1080,11 +1113,19 @@ class Lowering {
         this.blockPosVars = new Map(savedBlockPosVars);
         // In foreach body, the binding maps to @s
         this.varMap.set(stmt.binding, '@s');
+        // Track entity context for type narrowing
+        const selectorEntityType = (0, entity_hierarchy_1.getBaseSelectorType)(selector);
+        if (selectorEntityType) {
+            this.entityContextStack.push(selectorEntityType);
+        }
         this.builder.startBlock('entry');
         this.lowerBlock(stmt.body);
         if (!this.builder.isBlockSealed()) {
             this.builder.emitReturn();
         }
+        if (selectorEntityType) {
+            this.entityContextStack.pop();
+        }
         const subFn = this.builder.build(subFnName, [], false);
         this.functions.push(subFn);
         // Restore
@@ -1213,6 +1254,17 @@ class Lowering {
     lowerAsBlockStmt(stmt) {
         const selector = this.selectorToString(stmt.selector);
         const subFnName = `${this.currentFn}/as_${this.foreachCounter++}`;
+        // Check for impossible type assertions (W_IMPOSSIBLE_AS)
+        const innerType = (0, entity_hierarchy_1.getBaseSelectorType)(selector);
+        const outerType = this.currentEntityContext();
+        if (innerType && outerType !== 'Entity' && innerType !== 'Entity' && !(0, entity_hierarchy_1.areCompatibleTypes)(outerType, innerType)) {
+            this.warnings.push({
+                message: `Impossible type assertion: @s is ${outerType} but as-block targets ${innerType}`,
+                code: 'W_IMPOSSIBLE_AS',
+                line: stmt.span?.line,
+                col: stmt.span?.col,
+            });
+        }
         this.builder.emitRaw(`execute as ${selector} run function ${this.namespace}:${subFnName}`);
         // Create sub-function
         const savedBuilder = this.builder;
@@ -1221,11 +1273,18 @@ class Lowering {
         this.builder = new LoweringBuilder();
         this.varMap = new Map(savedVarMap);
         this.blockPosVars = new Map(savedBlockPosVars);
+        // Track entity context inside as-block
+        if (innerType) {
+            this.entityContextStack.push(innerType);
+        }
         this.builder.startBlock('entry');
         this.lowerBlock(stmt.body);
         if (!this.builder.isBlockSealed()) {
             this.builder.emitReturn();
         }
+        if (innerType) {
+            this.entityContextStack.pop();
+        }
         const subFn = this.builder.build(subFnName, [], false);
         this.functions.push(subFn);
         this.builder = savedBuilder;

package/dist/parser/index.js

@@ -32,11 +32,21 @@ const ENTITY_TYPE_NAMES = new Set([
     'Creeper',
     'Spider',
     'Enderman',
+    'Blaze',
+    'Witch',
+    'Slime',
+    'ZombieVillager',
+    'Husk',
+    'Drowned',
+    'Stray',
+    'WitherSkeleton',
+    'CaveSpider',
     'Pig',
     'Cow',
     'Sheep',
     'Chicken',
     'Villager',
+    'WanderingTrader',
     'ArmorStand',
     'Item',
     'Arrow',
@@ -384,7 +394,18 @@ class Parser {
         }
         else if (token.kind === 'ident') {
             this.advance();
-            type = { kind: 'struct', name: token.value };
+            if (token.value === 'selector' && this.check('<')) {
+                this.advance(); // consume <
+                const entityType = this.expect('ident').value;
+                this.expect('>');
+                type = { kind: 'selector', entityType };
+            }
+            else if (token.value === 'selector') {
+                type = { kind: 'selector' };
+            }
+            else {
+                type = { kind: 'struct', name: token.value };
+            }
         }
         else {
             this.error(`Expected type, got '${token.kind}'`);