redscript-mc 1.2.30 → 2.0.0

package/src/codegen/structure/index.ts

@@ -1,346 +0,0 @@
-import { Lexer } from '../../lexer'
-import { Parser } from '../../parser'
-import { Lowering } from '../../lowering'
-import { nbt, TagType, writeNbt, type CompoundTag, type NbtTag } from '../../nbt'
-import { createEmptyOptimizationStats, mergeOptimizationStats, type OptimizationStats } from '../../optimizer/commands'
-import { optimizeWithStats } from '../../optimizer/passes'
-import { optimizeForStructure, optimizeForStructureWithStats } from '../../optimizer/structure'
-import { eliminateDeadCode } from '../../optimizer/dce'
-import { preprocessSource } from '../../compile'
-import type { IRCommand, IRFunction, IRModule } from '../../ir/types'
-import type { DatapackFile } from '../mcfunction'
-import { EVENT_TYPES, isEventTypeName, type EventTypeName } from '../../events/types'
-import { VarAllocator } from '../var-allocator'
-
-const DATA_VERSION = 3953
-const MAX_WIDTH = 16
-const OBJ = 'rs'
-
-const PALETTE_IMPULSE = 0
-const PALETTE_CHAIN_UNCONDITIONAL = 1
-const PALETTE_CHAIN_CONDITIONAL = 2
-const PALETTE_REPEAT = 3
-
-const palette = [
-  { Name: 'minecraft:command_block', Properties: { conditional: 'false', facing: 'east' } },
-  { Name: 'minecraft:chain_command_block', Properties: { conditional: 'false', facing: 'east' } },
-  { Name: 'minecraft:chain_command_block', Properties: { conditional: 'true', facing: 'east' } },
-  { Name: 'minecraft:repeating_command_block', Properties: { conditional: 'false', facing: 'east' } },
-  { Name: 'minecraft:air', Properties: {} },
-]
-
-interface CommandEntry {
-  functionName: string
-  lineNumber: number
-  command: string
-  state: number
-  conditional: boolean
-  isRepeat: boolean
-}
-
-export interface StructureBlockInfo {
-  command: string
-  conditional: boolean
-  state: number
-  functionName: string
-  lineNumber: number
-}
-
-export interface StructureCompileResult {
-  buffer: Buffer
-  blockCount: number
-  blocks: StructureBlockInfo[]
-  stats?: OptimizationStats
-}
-
-export interface StructureCompileOptions {
-  dce?: boolean
-  mangle?: boolean
-}
-
-function escapeJsonString(value: string): string {
-  return JSON.stringify(value).slice(1, -1)
-}
-
-function collectConsts(fn: IRFunction): Set<number> {
-  const consts = new Set<number>()
-  for (const block of fn.blocks) {
-    for (const instr of block.instrs) {
-      if (instr.op === 'assign' && instr.src.kind === 'const') consts.add(instr.src.value)
-      if (instr.op === 'binop') {
-        if (instr.lhs.kind === 'const') consts.add(instr.lhs.value)
-        if (instr.rhs.kind === 'const') consts.add(instr.rhs.value)
-      }
-      if (instr.op === 'cmp') {
-        if (instr.lhs.kind === 'const') consts.add(instr.lhs.value)
-        if (instr.rhs.kind === 'const') consts.add(instr.rhs.value)
-      }
-    }
-    if (block.term.op === 'return' && block.term.value?.kind === 'const') {
-      consts.add(block.term.value.value)
-    }
-  }
-  return consts
-}
-
-function collectCommandEntriesFromModule(module: IRModule, mangle = false): CommandEntry[] {
-  const alloc = new VarAllocator(mangle)
-  const entries: CommandEntry[] = []
-  const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName)
-  const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName!))
-  const eventHandlers = module.functions.filter((fn): fn is IRFunction & { eventHandler: { eventType: EventTypeName; tag: string } } =>
-    !!fn.eventHandler && isEventTypeName(fn.eventHandler.eventType)
-  )
-  const eventTypes = new Set<EventTypeName>(eventHandlers.map(fn => fn.eventHandler.eventType))
-  const loadCommands = [
-    `scoreboard objectives add ${OBJ} dummy`,
-    ...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(value => `scoreboard players set ${alloc.constant(value)} ${OBJ} ${value}`),
-  ]
-
-  for (const eventType of eventTypes) {
-    if (eventType === 'PlayerDeath') {
-      loadCommands.push('scoreboard objectives add rs.deaths deathCount')
-    } else if (eventType === 'EntityKill') {
-      loadCommands.push('scoreboard objectives add rs.kills totalKillCount')
-    }
-  }
-
-  // Call @load functions from __load
-  for (const fn of module.functions) {
-    if (fn.isLoadInit) {
-      loadCommands.push(`function ${module.namespace}:${fn.name}`)
-    }
-  }
-
-  const sections: Array<{ name: string; commands: IRCommand[]; repeat?: boolean }> = []
-
-  if (loadCommands.length > 0) {
-    sections.push({
-      name: '__load',
-      commands: loadCommands.map(cmd => ({ cmd })),
-    })
-  }
-
-  for (const triggerName of triggerNames) {
-    const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName)
-    sections.push({
-      name: `__trigger_${triggerName}_dispatch`,
-      commands: [
-        ...handlers.map(handler => ({ cmd: `function ${module.namespace}:${handler.name}` })),
-        { cmd: `scoreboard players set @s ${triggerName} 0` },
-        { cmd: `scoreboard players enable @s ${triggerName}` },
-      ],
-    })
-  }
-
-  for (const fn of module.functions) {
-    if (!fn.commands || fn.commands.length === 0) continue
-    sections.push({
-      name: fn.name,
-      commands: fn.commands,
-    })
-  }
-
-  const tickCommands: IRCommand[] = []
-  for (const fn of module.functions.filter(candidate => candidate.isTickLoop)) {
-    tickCommands.push({ cmd: `function ${module.namespace}:${fn.name}` })
-  }
-  if (triggerNames.size > 0) {
-    for (const triggerName of triggerNames) {
-      tickCommands.push({
-        cmd: `execute as @a[scores={${triggerName}=1..}] run function ${module.namespace}:__trigger_${triggerName}_dispatch`,
-      })
-    }
-  }
-  if (eventHandlers.length > 0) {
-    for (const eventType of eventTypes) {
-      const tag = EVENT_TYPES[eventType].tag
-      const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType)
-      for (const handler of handlers) {
-        tickCommands.push({
-          cmd: `execute as @a[tag=${tag}] run function ${module.namespace}:${handler.name}`,
-        })
-      }
-      tickCommands.push({
-        cmd: `tag @a[tag=${tag}] remove ${tag}`,
-      })
-    }
-  }
-  if (tickCommands.length > 0) {
-    sections.push({
-      name: '__tick',
-      commands: tickCommands,
-      repeat: true,
-    })
-  }
-
-  for (const section of sections) {
-    for (let i = 0; i < section.commands.length; i++) {
-      const command = section.commands[i]
-      const state =
-        i === 0
-          ? (section.repeat ? PALETTE_REPEAT : PALETTE_IMPULSE)
-          : (command.conditional ? PALETTE_CHAIN_CONDITIONAL : PALETTE_CHAIN_UNCONDITIONAL)
-
-      entries.push({
-        functionName: section.name,
-        lineNumber: i + 1,
-        command: command.cmd,
-        conditional: Boolean(command.conditional),
-        state,
-        isRepeat: Boolean(section.repeat && i === 0),
-      })
-    }
-  }
-
-  return entries
-}
-
-function toFunctionName(file: DatapackFile): string | null {
-  const match = file.path.match(/^data\/[^/]+\/function\/(.+)\.mcfunction$/)
-  return match?.[1] ?? null
-}
-
-function collectCommandEntriesFromFiles(files: DatapackFile[]): CommandEntry[] {
-  const entries: CommandEntry[] = []
-
-  for (const file of files) {
-    const functionName = toFunctionName(file)
-    if (!functionName) continue
-
-    const lines = file.content.split('\n')
-    let isFirstCommand = true
-    const isTickFunction = functionName === '__tick'
-
-    for (let i = 0; i < lines.length; i++) {
-      const command = lines[i].trim()
-      if (command === '' || command.startsWith('#')) continue
-
-      const state = isFirstCommand
-        ? (isTickFunction ? PALETTE_REPEAT : PALETTE_IMPULSE)
-        : PALETTE_CHAIN_UNCONDITIONAL
-
-      entries.push({
-        functionName,
-        lineNumber: i + 1,
-        command,
-        conditional: false,
-        state,
-        isRepeat: isTickFunction && isFirstCommand,
-      })
-
-      isFirstCommand = false
-    }
-  }
-
-  return entries
-}
-
-function createPaletteTag(): CompoundTag[] {
-  return palette.map(entry =>
-    nbt.compound({
-      Name: nbt.string(entry.Name),
-      Properties: nbt.compound(
-        Object.fromEntries(
-          Object.entries(entry.Properties).map(([key, value]) => [key, nbt.string(value)])
-        )
-      ),
-    })
-  )
-}
-
-function createBlockEntityTag(entry: CommandEntry): NbtTag {
-  return nbt.compound({
-    id: nbt.string('minecraft:command_block'),
-    Command: nbt.string(entry.command),
-    auto: nbt.byte(entry.isRepeat ? 1 : 0),
-    powered: nbt.byte(0),
-    conditionMet: nbt.byte(0),
-    UpdateLastExecution: nbt.byte(1),
-    LastExecution: nbt.long(0n),
-    TrackOutput: nbt.byte(1),
-    SuccessCount: nbt.int(0),
-    LastOutput: nbt.string(''),
-    CustomName: nbt.string(`{"text":"${escapeJsonString(`${entry.functionName}:${entry.lineNumber}`)}"}`),
-  })
-}
-
-function createBlockTag(entry: CommandEntry, index: number): CompoundTag {
-  const x = index % MAX_WIDTH
-  const z = Math.floor(index / MAX_WIDTH) % MAX_WIDTH
-  const y = Math.floor(index / (MAX_WIDTH * MAX_WIDTH))
-
-  return nbt.compound({
-    pos: nbt.list(TagType.Int, [nbt.int(x), nbt.int(y), nbt.int(z)]),
-    state: nbt.int(entry.state),
-    nbt: createBlockEntityTag(entry),
-  })
-}
-
-export function generateStructure(input: IRModule | DatapackFile[], options?: { mangle?: boolean }): StructureCompileResult {
-  const entries = Array.isArray(input)
-    ? collectCommandEntriesFromFiles(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))
-  const sizeY = Math.max(1, Math.ceil(entries.length / (MAX_WIDTH * MAX_WIDTH)) || 1)
-
-  const root = nbt.compound({
-    DataVersion: nbt.int(DATA_VERSION),
-    size: nbt.list(TagType.Int, [nbt.int(sizeX), nbt.int(sizeY), nbt.int(sizeZ)]),
-    palette: nbt.list(TagType.Compound, createPaletteTag()),
-    blocks: nbt.list(TagType.Compound, blockTags),
-    entities: nbt.list(TagType.Compound, []),
-  })
-
-  return {
-    buffer: writeNbt(root, ''),
-    blockCount: entries.length,
-    blocks: entries.map(entry => ({
-      command: entry.command,
-      conditional: entry.conditional,
-      state: entry.state,
-      functionName: entry.functionName,
-      lineNumber: entry.lineNumber,
-    })),
-  }
-}
-
-export function compileToStructure(
-  source: string,
-  namespace: string,
-  filePath?: string,
-  options: StructureCompileOptions = {}
-): StructureCompileResult {
-  const preprocessedSource = preprocessSource(source, { filePath })
-  const tokens = new Lexer(preprocessedSource, filePath).tokenize()
-  const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
-  const dceResult = options.dce ?? true ? eliminateDeadCode(parsedAst) : { program: parsedAst, warnings: [] }
-  const ast = dceResult.program
-  const ir = new Lowering(namespace).lower(ast)
-  const stats = createEmptyOptimizationStats()
-  const optimizedIRFunctions = ir.functions.map(fn => {
-    const optimized = optimizeWithStats(fn)
-    mergeOptimizationStats(stats, optimized.stats)
-    return optimized.fn
-  })
-  const structureOptimized = optimizeForStructureWithStats(optimizedIRFunctions, namespace)
-  mergeOptimizationStats(stats, structureOptimized.stats)
-  const optimizedModule: IRModule = {
-    ...ir,
-    functions: structureOptimized.functions,
-  }
-  return {
-    ...generateStructure(optimizedModule, { mangle: options.mangle }),
-    stats,
-  }
-}

package/src/codegen/var-allocator.ts

@@ -1,104 +0,0 @@
-/**
- * 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 class VarAllocator {
-  private readonly mangle: boolean
-  private seq = 0
-  private readonly varCache = new Map<string, string>()
-  private readonly constCache = new Map<number, string>()
-  private readonly internalCache = new Map<string, string>()
-
-  constructor(mangle = true) {
-    this.mangle = mangle
-  }
-
-  /** Allocate a name for a user variable. Strips leading '$' if present. */
-  alloc(originalName: string): string {
-    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: number): string {
-    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
-  }
-
-  /**
-   * Look up the allocated name for a raw scoreboard fake-player name such as
-   * "$_2", "$x", "$p0", or "$ret".  Returns the mangled name when mangle=true,
-   * or the original name when mangle=false or the name is not yet known.
-   *
-   * Unlike alloc/internal/constant this does NOT create a new slot — it only
-   * resolves names that were already registered.  Used by the codegen to
-   * rewrite variable references inside `raw` IR instructions.
-   */
-  resolve(rawName: string): string {
-    const clean = rawName.startsWith('$') ? rawName.slice(1) : rawName
-    // Check every cache in priority order: vars, internals, consts
-    return (
-      this.varCache.get(clean) ??
-      this.internalCache.get(clean) ??
-      rawName  // not registered → return as-is (literal fake player, not a var)
-    )
-  }
-
-  /**
-   * Rewrite all $varname tokens in a raw mcfunction command string so that
-   * IR variable names are replaced by their allocated (possibly mangled) names.
-   * Tokens that are not registered in the allocator are left untouched (they
-   * are literal scoreboard fake-player names like "out" or "#rs").
-   */
-  resolveRaw(cmd: string): string {
-    return cmd.replace(/\$[A-Za-z_][A-Za-z0-9_]*/g, (tok) => this.resolve(tok))
-  }
-
-  /** Allocate a name for a compiler internal (e.g. "ret", "p0"). */
-  internal(suffix: string): string {
-    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, ... */
-  private nextSeqName(): string {
-    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(): Record<string, string> {
-    const map: Record<string, string> = {}
-    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
-  }
-}

package/src/ir/builder.ts

@@ -1,116 +0,0 @@
-/**
- * IRBuilder — helper for constructing IR programmatically.
- * AST → IR lowering uses this.
- */
-
-import type { IRBlock, IRFunction, IRInstr, IRModule, Operand, Terminator } from './types'
-
-export class IRBuilder {
-  private tempCount = 0
-  private labelCount = 0
-  private currentBlock: IRBlock | null = null
-  private blocks: IRBlock[] = []
-  private locals = new Set<string>()
-
-  // -------------------------------------------------------------------------
-  // Names
-  // -------------------------------------------------------------------------
-
-  freshTemp(): string {
-    const name = `$t${this.tempCount++}`
-    this.locals.add(name)
-    return name
-  }
-
-  freshLabel(hint = 'L'): string {
-    return `${hint}_${this.labelCount++}`
-  }
-
-  // -------------------------------------------------------------------------
-  // Block management
-  // -------------------------------------------------------------------------
-
-  startBlock(label: string): void {
-    this.currentBlock = { label, instrs: [], term: { op: 'return' } }
-  }
-
-  private get block(): IRBlock {
-    if (!this.currentBlock) throw new Error('No active block')
-    return this.currentBlock
-  }
-
-  private sealBlock(term: Terminator): void {
-    this.block.term = term
-    this.blocks.push(this.block)
-    this.currentBlock = null
-  }
-
-  // -------------------------------------------------------------------------
-  // Emit instructions
-  // -------------------------------------------------------------------------
-
-  emitAssign(dst: string, src: Operand): void {
-    this.locals.add(dst)
-    this.block.instrs.push({ op: 'assign', dst, src })
-  }
-
-  emitBinop(dst: string, lhs: Operand, bop: IRInstr & { op: 'binop' } extends { bop: infer B } ? B : never, rhs: Operand): void
-  emitBinop(dst: string, lhs: Operand, bop: '+' | '-' | '*' | '/' | '%', rhs: Operand): void {
-    this.locals.add(dst)
-    this.block.instrs.push({ op: 'binop', dst, lhs, bop, rhs })
-  }
-
-  emitCmp(dst: string, lhs: Operand, cop: '==' | '!=' | '<' | '<=' | '>' | '>=', rhs: Operand): void {
-    this.locals.add(dst)
-    this.block.instrs.push({ op: 'cmp', dst, lhs, cop, rhs })
-  }
-
-  emitCall(fn: string, args: Operand[], dst?: string): void {
-    if (dst) this.locals.add(dst)
-    this.block.instrs.push({ op: 'call', fn, args, dst })
-  }
-
-  emitRaw(cmd: string): void {
-    this.block.instrs.push({ op: 'raw', cmd })
-  }
-
-  // -------------------------------------------------------------------------
-  // Terminators
-  // -------------------------------------------------------------------------
-
-  emitJump(target: string): void {
-    this.sealBlock({ op: 'jump', target })
-  }
-
-  emitJumpIf(cond: string, then: string, else_: string): void {
-    this.sealBlock({ op: 'jump_if', cond, then, else_ })
-  }
-
-  emitReturn(value?: Operand): void {
-    this.sealBlock({ op: 'return', value })
-  }
-
-  emitTickYield(continuation: string): void {
-    this.sealBlock({ op: 'tick_yield', continuation })
-  }
-
-  // -------------------------------------------------------------------------
-  // Build
-  // -------------------------------------------------------------------------
-
-  build(name: string, params: string[], isTickLoop = false): IRFunction {
-    return {
-      name,
-      params,
-      locals: Array.from(this.locals),
-      blocks: this.blocks,
-      isTickLoop,
-    }
-  }
-}
-
-import type { GlobalVar } from './types'
-
-export function buildModule(namespace: string, fns: IRFunction[], globals: GlobalVar[] = []): IRModule {
-  return { namespace, functions: fns, globals }
-}

package/src/ir/types.ts

@@ -1,134 +0,0 @@
-/**
- * RedScript IR — Three-Address Code (TAC)
- *
- * Compilation pipeline:
- *   Source → AST → IR → (optimize) → CodeGen → mcfunction / cmdblock
- *
- * Variable storage in MC Java Edition:
- *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
- *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
- *   - Return value  → fake player $ret
- *   - Temporaries   → $_0, $_1, ...
- */
-
-// ---------------------------------------------------------------------------
-// Operands
-// ---------------------------------------------------------------------------
-
-export type Operand =
-  | { kind: 'var';     name: string }        // scoreboard fake player
-  | { kind: 'const';   value: number }       // integer literal
-  | { kind: 'storage'; path: string }        // NBT storage path (e.g. "redscript:heap data.x")
-  | { kind: 'param';   index: number }       // function parameter slot (alloc.internal('p{i}')), avoids mangle collision
-
-// ---------------------------------------------------------------------------
-// Binary operators (all map to `scoreboard players operation`)
-// ---------------------------------------------------------------------------
-
-export type BinOp = '+' | '-' | '*' | '/' | '%'
-export type CmpOp = '==' | '!=' | '<' | '<=' | '>' | '>='
-
-// ---------------------------------------------------------------------------
-// IR Instructions
-// ---------------------------------------------------------------------------
-
-export type IRInstr =
-  // x = src
-  | { op: 'assign';    dst: string; src: Operand }
-
-  // dst = lhs bop rhs
-  | { op: 'binop';     dst: string; lhs: Operand; bop: BinOp; rhs: Operand }
-
-  // dst = (lhs cop rhs) ? 1 : 0
-  | { op: 'cmp';       dst: string; lhs: Operand; cop: CmpOp; rhs: Operand }
-
-  // goto label
-  | { op: 'jump';      target: string }
-
-  // if cond != 0 goto target
-  | { op: 'jump_if';   cond: string; target: string }
-
-  // if cond == 0 goto target
-  | { op: 'jump_unless'; cond: string; target: string }
-
-  // dst = fn(args)
-  | { op: 'call';      fn: string; args: Operand[]; dst?: string }
-
-  // return value (optional)
-  | { op: 'return';    value?: Operand }
-
-  // label declaration (block entry point)
-  | { op: 'label';     id: string }
-
-  // raw MC command passthrough (escape hatch)
-  | { op: 'raw';       cmd: string }
-
-  // wait one game tick (command block target only)
-  // maps to: schedule function <continuation> 1t replace
-  | { op: 'tick_yield' }
-
-// ---------------------------------------------------------------------------
-// Basic Block — straight-line code, ends with a terminator
-// ---------------------------------------------------------------------------
-
-export type Terminator =
-  | { op: 'jump';        target: string }
-  | { op: 'jump_if';     cond: string; then: string; else_: string }
-  | { op: 'jump_unless'; cond: string; then: string; else_: string }
-  | { op: 'return';      value?: Operand }
-  | { op: 'tick_yield';  continuation: string }
-
-export interface IRBlock {
-  label: string
-  instrs: IRInstr[]       // non-terminator instructions
-  term: Terminator
-}
-
-export interface IRCommand {
-  cmd: string
-  conditional?: boolean
-  label?: string
-}
-
-// ---------------------------------------------------------------------------
-// Function
-// ---------------------------------------------------------------------------
-
-export interface IRFunction {
-  name: string
-  params: string[]         // parameter names (passed via fake players)
-  locals: string[]         // all local variable names
-  blocks: IRBlock[]        // blocks[0] = entry block
-  commands?: IRCommand[]   // structure target command stream
-  isTickLoop?: boolean     // true → Repeat command block (runs every tick)
-  isLoadInit?: boolean     // true → called from __load.mcfunction
-  requiredLoads?: string[] // @requires("fn") — these fns are also called from __load when this fn is compiled in
-  isTriggerHandler?: boolean  // true → handles a trigger event
-  triggerName?: string        // the trigger objective name
-  eventTrigger?: {
-    kind: 'advancement' | 'craft' | 'death' | 'login' | 'join_team'
-    value?: string
-  }
-  eventHandler?: {
-    eventType: string
-    tag: string
-  }
-  // MC 1.20.2+ macro function support
-  isMacroFunction?: boolean   // true → function uses MC macro syntax ($-prefixed commands)
-  macroParamNames?: string[]  // parameter names that are passed via NBT macro (not just scoreboard)
-}
-
-// ---------------------------------------------------------------------------
-// Module — top-level compilation unit
-// ---------------------------------------------------------------------------
-
-export interface GlobalVar {
-  name: string
-  init: number
-}
-
-export interface IRModule {
-  namespace: string        // datapack namespace (e.g. "mypack")
-  functions: IRFunction[]
-  globals: GlobalVar[]     // global variable declarations with init values
-}