redscript-mc 1.2.25 → 1.2.26

package/src/optimizer/dce.ts

@@ -134,13 +134,18 @@ export class DeadCodeEliminator {
     const entries = new Set<string>()
 
     for (const fn of program.declarations) {
-      // All top-level functions are entry points (callable via /function)
-      // Exception: functions starting with _ are considered private/internal
-      if (!fn.name.startsWith('_')) {
-        entries.add(fn.name)
+      // Library functions (from `module library;` or `librarySources`) are
+      // NOT MC entry points — they're only kept if reachable from user code.
+      // Exception: decorators like @tick / @load / @on / @keep always force inclusion.
+      if (!fn.isLibraryFn) {
+        // All top-level non-library functions are entry points (callable via /function)
+        // Exception: functions starting with _ are considered private/internal
+        if (!fn.name.startsWith('_')) {
+          entries.add(fn.name)
+        }
       }
 
-      // Decorated functions are always entry points (even if prefixed with _)
+      // Decorated functions are always entry points regardless of library mode or _ prefix
       if (fn.decorators.some(decorator => [
         'tick',
         'load',
@@ -172,6 +177,18 @@ export class DeadCodeEliminator {
 
     this.reachableFunctions.add(fnName)
     this.collectFunctionRefs(fn)
+
+    // @requires("dep") — when fn is reachable, its required dependencies are
+    // also pulled into the reachable set so they survive DCE.
+    for (const decorator of fn.decorators) {
+      if (decorator.name === 'require_on_load') {
+        for (const arg of decorator.rawArgs ?? []) {
+          if (arg.kind === 'string') {
+            this.markReachable(arg.value)
+          }
+        }
+      }
+    }
   }
 
   private collectFunctionRefs(fn: FnDecl): void {

package/src/optimizer/passes.ts

@@ -95,30 +95,43 @@ export function copyPropagation(fn: IRFunction): IRFunction {
       return copies.get(op.name) ?? op
     }
 
+    /**
+     * Invalidate all copies that became stale because `written` was modified.
+     * When $y is overwritten, any mapping copies[$tmp] = $y is now stale:
+     * reading $tmp would return the OLD $y value via the copy, but $y now holds
+     * a different value.  Remove both the direct entry (copies[$y]) and every
+     * reverse entry that points at $y.
+     */
+    function invalidate(written: string): void {
+      copies.delete(written)
+      for (const [k, v] of copies) {
+        if (v.kind === 'var' && v.name === written) copies.delete(k)
+      }
+    }
+
     const newInstrs: IRInstr[] = []
     for (const instr of block.instrs) {
       switch (instr.op) {
         case 'assign': {
           const src = resolve(instr.src)
+          invalidate(instr.dst)
           // Only propagate scalars (var or const), not storage
           if (src.kind === 'var' || src.kind === 'const') {
             copies.set(instr.dst, src)
-          } else {
-            copies.delete(instr.dst)
           }
           newInstrs.push({ ...instr, src })
           break
         }
         case 'binop':
-          copies.delete(instr.dst)
+          invalidate(instr.dst)
           newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) })
           break
         case 'cmp':
-          copies.delete(instr.dst)
+          invalidate(instr.dst)
           newInstrs.push({ ...instr, lhs: resolve(instr.lhs), rhs: resolve(instr.rhs) })
           break
         case 'call':
-          if (instr.dst) copies.delete(instr.dst)
+          if (instr.dst) invalidate(instr.dst)
           newInstrs.push({ ...instr, args: instr.args.map(resolve) })
           break
         default:

package/src/optimizer/structure.ts

@@ -24,7 +24,8 @@ function varRef(name: string): string {
 function operandToScore(op: Operand): string {
   if (op.kind === 'var') return `${varRef(op.name)} ${OBJ}`
   if (op.kind === 'const') return `$const_${op.value} ${OBJ}`
-  throw new Error(`Cannot convert storage operand to score: ${op.path}`)
+  if (op.kind === 'param') return `$p${op.index} ${OBJ}`
+  throw new Error(`Cannot convert storage operand to score: ${(op as any).path}`)
 }
 
 function emitInstr(instr: IRInstr, namespace: string): IRCommand[] {
@@ -38,6 +39,10 @@ function emitInstr(instr: IRInstr, namespace: string): IRCommand[] {
         commands.push({
           cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = ${varRef(instr.src.name)} ${OBJ}`,
         })
+      } else if (instr.src.kind === 'param') {
+        commands.push({
+          cmd: `scoreboard players operation ${varRef(instr.dst)} ${OBJ} = $p${instr.src.index} ${OBJ}`,
+        })
       } else {
         commands.push({
           cmd: `execute store result score ${varRef(instr.dst)} ${OBJ} run data get storage ${instr.src.path}`,

package/src/parser/index.ts

@@ -76,6 +76,11 @@ export class Parser {
   private pos: number = 0
   private sourceLines: string[]
   private filePath?: string
+  /** Set to true once `module library;` is seen — all subsequent fn declarations
+   *  will be marked isLibraryFn=true.  When library sources are parsed via the
+   *  `librarySources` compile option, each source is parsed by its own fresh
+   *  Parser instance, so this flag never bleeds into user code. */
+  private inLibraryMode: boolean = false
 
   constructor(tokens: Token[], source?: string, filePath?: string) {
     this.tokens = tokens
@@ -169,6 +174,7 @@ export class Parser {
     const implBlocks: ImplBlock[] = []
     const enums: EnumDecl[] = []
     const consts: ConstDecl[] = []
+    let isLibrary = false
 
     // Check for namespace declaration
     if (this.check('namespace')) {
@@ -178,6 +184,20 @@ export class Parser {
       this.expect(';')
     }
 
+    // Check for module declaration: `module library;`
+    // Library-mode: all functions parsed from this point are marked isLibraryFn=true.
+    // When using the `librarySources` compile option, each library source is parsed
+    // by its own fresh Parser — so this flag never bleeds into user code.
+    if (this.check('module')) {
+      this.advance()
+      const modKind = this.expect('ident')
+      if (modKind.value === 'library') {
+        isLibrary = true
+        this.inLibraryMode = true
+      }
+      this.expect(';')
+    }
+
     // Parse struct and function declarations
     while (!this.check('eof')) {
       if (this.check('let')) {
@@ -199,7 +219,7 @@ export class Parser {
       }
     }
 
-    return { namespace, globals, declarations, structs, implBlocks, enums, consts }
+    return { namespace, globals, declarations, structs, implBlocks, enums, consts, isLibrary }
   }
 
   // -------------------------------------------------------------------------
@@ -322,7 +342,11 @@ export class Parser {
 
     const body = this.parseBlock()
 
-    return this.withLoc({ name, params, returnType, decorators, body }, fnToken)
+    const fn: import('../ast/types').FnDecl = this.withLoc(
+      { name, params, returnType, decorators, body, isLibraryFn: this.inLibraryMode || undefined },
+      fnToken,
+    )
+    return fn
   }
 
   /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
@@ -397,6 +421,27 @@ export class Parser {
       }
     }
 
+    // @require_on_load(fn_name) — when this fn is used, fn_name is called from __load.
+    // Accepts bare identifiers (with optional leading _) or quoted strings.
+    if (name === 'require_on_load') {
+      const rawArgs: NonNullable<Decorator['rawArgs']> = []
+      for (const part of argsStr.split(',')) {
+        const trimmed = part.trim()
+        // Bare identifier: @require_on_load(_math_init)
+        const identMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)$/)
+        if (identMatch) {
+          rawArgs.push({ kind: 'string', value: identMatch[1] })
+        } else {
+          // Quoted string fallback: @require_on_load("_math_init")
+          const strMatch = trimmed.match(/^"([^"]*)"$/)
+          if (strMatch) {
+            rawArgs.push({ kind: 'string', value: strMatch[1] })
+          }
+        }
+      }
+      return { name, rawArgs }
+    }
+
     // Handle key=value format (e.g., rate=20)
     for (const part of argsStr.split(',')) {
       const [key, val] = part.split('=').map(s => s.trim())

package/src/runtime/index.ts

@@ -266,6 +266,9 @@ export class MCRuntime {
   // Flag to stop function execution (for return)
   private shouldReturn: boolean = false
 
+  // Current MC macro context: key → value (set by 'function ... with storage')
+  private currentMacroContext: Record<string, any> | null = null
+
   constructor(namespace: string) {
     this.namespace = namespace
     // Initialize default objective
@@ -363,6 +366,13 @@ export class MCRuntime {
     cmd = cmd.trim()
     if (!cmd || cmd.startsWith('#')) return true
 
+    // MC macro command: line starts with '$'.
+    // Expand $(key) placeholders from currentMacroContext, then execute.
+    if (cmd.startsWith('$')) {
+      const expanded = this.expandMacro(cmd.slice(1))
+      return this.execCommand(expanded, executor)
+    }
+
     // Parse command
     if (cmd.startsWith('scoreboard ')) {
       return this.execScoreboard(cmd)
@@ -542,7 +552,10 @@ export class MCRuntime {
     // Track execute state
     let currentExecutor = executor
     let condition: boolean = true
-    let storeTarget: { player: string; objective: string; type: 'result' | 'success' } | null = null
+    let storeTarget: 
+      | { player: string; objective: string; type: 'result' | 'success' }
+      | { storagePath: string; field: string; type: 'result' }
+      | null = null
 
     while (rest.length > 0) {
       rest = rest.trimStart()
@@ -557,7 +570,11 @@ export class MCRuntime {
           const value = storeTarget.type === 'result'
             ? (this.returnValue ?? (result ? 1 : 0))
             : (result ? 1 : 0)
-          this.setScore(storeTarget.player, storeTarget.objective, value)
+          if ('storagePath' in storeTarget) {
+            this.setStorageField(storeTarget.storagePath, storeTarget.field, value)
+          } else {
+            this.setScore(storeTarget.player, storeTarget.objective, value)
+          }
         }
 
         return result
@@ -630,15 +647,34 @@ export class MCRuntime {
       // Handle 'unless score ...'
       if (rest.startsWith('unless score ')) {
         rest = rest.slice(13)
-        const scoreParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/)
-        if (scoreParts) {
-          const [, player, obj, rangeStr, remaining] = scoreParts
+        // unless score <player> <obj> matches <range>
+        const matchesParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/)
+        if (matchesParts) {
+          const [, player, obj, rangeStr, remaining] = matchesParts
           const range = parseRange(rangeStr)
           const score = this.getScore(player, obj)
           condition = condition && !matchesRange(score, range)
           rest = remaining.trim()
           continue
         }
+        // unless score <p1> <o1> <op> <p2> <o2>
+        const compareMatch = rest.match(/^(\S+)\s+(\S+)\s+([<>=]+)\s+(\S+)\s+(\S+)(.*)$/)
+        if (compareMatch) {
+          const [, p1, o1, op, p2, o2, remaining] = compareMatch
+          const v1 = this.getScore(p1, o1)
+          const v2 = this.getScore(p2, o2)
+          let matches = false
+          switch (op) {
+            case '=': matches = v1 === v2; break
+            case '<': matches = v1 < v2; break
+            case '<=': matches = v1 <= v2; break
+            case '>': matches = v1 > v2; break
+            case '>=': matches = v1 >= v2; break
+          }
+          condition = condition && !matches  // unless = negate
+          rest = remaining.trim()
+          continue
+        }
       }
 
       // Handle 'if entity <selector>'
@@ -661,6 +697,19 @@ export class MCRuntime {
         continue
       }
 
+      // Handle 'store result storage <ns:path> <field> <type> <scale>'
+      if (rest.startsWith('store result storage ')) {
+        rest = rest.slice(21)
+        // format: <ns:path> <field> <type> <scale> <run-cmd>
+        const storageParts = rest.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/)
+        if (storageParts) {
+          const [, storagePath, field, , , remaining] = storageParts
+          storeTarget = { storagePath, field, type: 'result' }
+          rest = remaining.trim()
+          continue
+        }
+      }
+
       // Handle 'store result score <player> <obj>'
       if (rest.startsWith('store result score ')) {
         rest = rest.slice(19)
@@ -695,7 +744,11 @@ export class MCRuntime {
       const value = storeTarget.type === 'result'
         ? (this.returnValue ?? (condition ? 1 : 0))
         : (condition ? 1 : 0)
-      this.setScore(storeTarget.player, storeTarget.objective, value)
+      if ('storagePath' in storeTarget) {
+        this.setStorageField(storeTarget.storagePath, storeTarget.field, value)
+      } else {
+        this.setScore(storeTarget.player, storeTarget.objective, value)
+      }
     }
 
     return condition
@@ -721,13 +774,39 @@ export class MCRuntime {
   // -------------------------------------------------------------------------
 
   private execFunctionCmd(cmd: string, executor?: Entity): boolean {
-    const fnName = cmd.slice(9).trim() // remove 'function '
+    let fnRef = cmd.slice(9).trim() // remove 'function '
+
+    // Handle 'function ns:name with storage ns:path' — MC macro calling convention.
+    // The called function may have $( ) placeholders that need to be expanded
+    // using the provided storage compound. We execute the function after
+    // expanding its macro context.
+    const withStorageMatch = fnRef.match(/^(\S+)\s+with\s+storage\s+(\S+)$/)
+    if (withStorageMatch) {
+      const [, actualFnName, storagePath] = withStorageMatch
+      const macroContext = this.getStorageCompound(storagePath) ?? {}
+      const outerShouldReturn = this.shouldReturn
+      const outerMacroCtx = this.currentMacroContext
+      this.currentMacroContext = macroContext
+      this.execFunction(actualFnName, executor)
+      this.currentMacroContext = outerMacroCtx
+      this.shouldReturn = outerShouldReturn
+      return true
+    }
+
     const outerShouldReturn = this.shouldReturn
-    this.execFunction(fnName, executor)
+    this.execFunction(fnRef, executor)
     this.shouldReturn = outerShouldReturn
     return true
   }
 
+  /** Expand MC macro placeholders: $(key) → value from currentMacroContext */
+  private expandMacro(cmd: string): string {
+    return cmd.replace(/\$\(([^)]+)\)/g, (_, key) => {
+      const val = this.currentMacroContext?.[key]
+      return val !== undefined ? String(val) : `$(${key})`
+    })
+  }
+
   // -------------------------------------------------------------------------
   // Data Commands
   // -------------------------------------------------------------------------
@@ -755,8 +834,19 @@ export class MCRuntime {
       return true
     }
 
-    // data get storage <ns:path> <field>
-    const getMatch = cmd.match(/^data get storage (\S+) (\S+)$/)
+    // data get storage <ns:path> <field>[<index>] [scale]  (array element access)
+    const getArrMatch = cmd.match(/^data get storage (\S+) (\S+)\[(\d+)\](?:\s+[\d.]+)?$/)
+    if (getArrMatch) {
+      const [, storagePath, field, indexStr] = getArrMatch
+      const arr = this.getStorageField(storagePath, field)
+      const idx = parseInt(indexStr, 10)
+      const value = Array.isArray(arr) ? arr[idx] : undefined
+      this.returnValue = typeof value === 'number' ? value : 0
+      return true
+    }
+
+    // data get storage <ns:path> <field> [scale]
+    const getMatch = cmd.match(/^data get storage (\S+) (\S+)(?:\s+[\d.]+)?$/)
     if (getMatch) {
       const [, storagePath, field] = getMatch
       const value = this.getStorageField(storagePath, field)
@@ -803,6 +893,14 @@ export class MCRuntime {
     }
   }
 
+  /** Return the whole storage compound at storagePath as a flat key→value map.
+   *  Used by 'function ... with storage' to provide macro context. */
+  private getStorageCompound(storagePath: string): Record<string, any> | null {
+    const data = this.storage.get(storagePath)
+    if (!data || typeof data !== 'object' || Array.isArray(data)) return null
+    return data as Record<string, any>
+  }
+
   private getStorageField(storagePath: string, field: string): any {
     const data = this.storage.get(storagePath) ?? {}
     const segments = this.parseStoragePath(field)

package/src/stdlib/advanced.mcrs

@@ -0,0 +1,249 @@
+// advanced.mcrs — Higher-order integer math and "fun" algorithms.
+//
+// Requires: math.mcrs (for lerp, smoothstep, mulfix, abs, isqrt, sqrt_fixed)
+//
+// Category 1: Number theory  — fib, is_prime, collatz_steps, digit_sum, reverse_int, mod_pow
+// Category 2: Hashing/noise  — hash_int, noise1d
+// Category 3: Curves         — bezier_quad, bezier_cubic
+// Category 4: Fractals 🤯    — mandelbrot_iter (fixed-point complex arithmetic)
+
+module library;
+
+// ─── Category 1: Number theory ───────────────────────────────────────────────
+
+// Fibonacci number F(n) using simple iteration.
+// Overflow: F(46) = 1836311903 ≈ INT_MAX; use n ≤ 46.
+// fib(0) == 0, fib(1) == 1, fib(10) == 55
+fn fib(n: int) -> int {
+    if (n <= 0) { return 0; }
+    if (n == 1) { return 1; }
+    let a: int = 0;
+    let b: int = 1;
+    let i: int = 2;
+    while (i <= n) {
+        let c: int = a + b;
+        a = b;
+        b = c;
+        i = i + 1;
+    }
+    return b;
+}
+
+// Primality test by trial division up to √n.
+// Returns 1 if n is prime, 0 otherwise.
+// is_prime(2) == 1, is_prime(4) == 0, is_prime(97) == 1
+fn is_prime(n: int) -> int {
+    if (n < 2) { return 0; }
+    if (n == 2) { return 1; }
+    if (n % 2 == 0) { return 0; }
+    let i: int = 3;
+    while (i * i <= n) {
+        if (n % i == 0) { return 0; }
+        i = i + 2;
+    }
+    return 1;
+}
+
+// Number of steps in the Collatz sequence starting at n until reaching 1.
+// collatz_steps(1)  == 0
+// collatz_steps(6)  == 8
+// collatz_steps(27) == 111   (world record among small numbers)
+fn collatz_steps(n: int) -> int {
+    if (n <= 1) { return 0; }
+    let x: int = n;
+    let steps: int = 0;
+    while (x != 1) {
+        if (x % 2 == 0) {
+            x = x / 2;
+        } else {
+            x = 3 * x + 1;
+        }
+        steps = steps + 1;
+    }
+    return steps;
+}
+
+// Sum of decimal digits.  Negative input uses absolute value.
+// digit_sum(123) == 6, digit_sum(0) == 0
+fn digit_sum(n: int) -> int {
+    let x: int = n;
+    if (x < 0) { x = 0 - x; }
+    if (x == 0) { return 0; }
+    let sum: int = 0;
+    while (x > 0) {
+        sum = sum + x % 10;
+        x = x / 10;
+    }
+    return sum;
+}
+
+// Count decimal digits.  0 has 1 digit.  Negative: counts absolute digits.
+// count_digits(0) == 1, count_digits(100) == 3
+fn count_digits(n: int) -> int {
+    let x: int = n;
+    if (x < 0) { x = 0 - x; }
+    if (x == 0) { return 1; }
+    let cnt: int = 0;
+    while (x > 0) {
+        cnt = cnt + 1;
+        x = x / 10;
+    }
+    return cnt;
+}
+
+// Reverse the decimal digits of an integer.  Sign is preserved.
+// reverse_int(12345) == 54321, reverse_int(-42) == -24
+fn reverse_int(n: int) -> int {
+    let x: int = n;
+    let neg: int = 0;
+    if (x < 0) { x = 0 - x; neg = 1; }
+    let result: int = 0;
+    while (x > 0) {
+        result = result * 10 + x % 10;
+        x = x / 10;
+    }
+    if (neg == 1) { return 0 - result; }
+    return result;
+}
+
+// Modular exponentiation: (base ^ exp) mod m  using fast O(log exp) squaring.
+// IMPORTANT: m must be ≤ 46340 to avoid b*b overflow (46340² < INT_MAX).
+// mod_pow(2, 10, 1000) == 24   (1024 mod 1000)
+fn mod_pow(base: int, exp: int, m: int) -> int {
+    if (m == 1) { return 0; }
+    let result: int = 1;
+    let b: int = base % m;
+    if (b < 0) { b = b + m; }
+    let e: int = exp;
+    while (e > 0) {
+        if (e % 2 == 1) {
+            result = result * b % m;
+        }
+        b = b * b % m;
+        e = e / 2;
+    }
+    return result;
+}
+
+// ─── Category 2: Hashing & noise ─────────────────────────────────────────────
+
+// Integer hash function.  Output is non-negative, range [0, ~2 × 10⁹).
+// Deterministic, no randomness — same input always produces the same output.
+// Suitable as a seeded pseudo-random value for procedural generation.
+// hash_int(0) != hash_int(1), repeatable across runs.
+fn hash_int(n: int) -> int {
+    let h: int = n;
+    if (h < 0) { h = 0 - h; }
+    h = h % 46340;               // Clamp so h² fits in int32
+    h = h * 46337 + 97;          // 46337 is prime; h*46337 ≤ 46340*46337 < INT_MAX
+    if (h < 0) { h = 0 - h; }
+    h = h % 46340;
+    h = h * 46337 + 211;
+    if (h < 0) { h = 0 - h; }
+    return h;
+}
+
+// 1D value noise.  Input x in fixed-point (scale = 1000).
+// Output in [0, 999] — smoothly interpolated between hashed lattice points.
+// noise1d(0) == noise1d(0), noise1d(500) is between noise1d(0) and noise1d(1000).
+fn noise1d(x: int) -> int {
+    let ix: int = x / 1000;
+    let frac: int = x % 1000;
+    // Handle negative x so frac is always in [0, 999]
+    if (frac < 0) {
+        ix = ix - 1;
+        frac = frac + 1000;
+    }
+    let h0: int = hash_int(ix) % 1000;
+    let h1: int = hash_int(ix + 1) % 1000;
+    if (h0 < 0) { h0 = 0 - h0; }
+    if (h1 < 0) { h1 = 0 - h1; }
+    // Smoothstep for C1 continuity
+    let t: int = smoothstep(0, 1000, frac);
+    return lerp(h0, h1, t);
+}
+
+// ─── Category 3: Curves ──────────────────────────────────────────────────────
+
+// Quadratic Bezier: B(t) = lerp(lerp(p0,p1,t), lerp(p1,p2,t), t)
+// De Casteljau's algorithm — numerically stable, safe for large coordinates.
+// t in [0, 1000] (fixed-point).
+//
+// bezier_quad(0, 500, 1000, 0)    == 0     (t=0: start)
+// bezier_quad(0, 500, 1000, 500)  == 500   (t=500: midpoint of curve)
+// bezier_quad(0, 500, 1000, 1000) == 1000  (t=1000: end)
+// bezier_quad(0, 1000, 0, 500)    == 500   (arch at midpoint)
+fn bezier_quad(p0: int, p1: int, p2: int, t: int) -> int {
+    let m0: int = lerp(p0, p1, t);
+    let m1: int = lerp(p1, p2, t);
+    return lerp(m0, m1, t);
+}
+
+// Cubic Bezier: 4-point curve using De Casteljau's algorithm.
+// t in [0, 1000].
+// bezier_cubic(0, 333, 667, 1000, 0)    == 0
+// bezier_cubic(0, 333, 667, 1000, 1000) == 1000
+fn bezier_cubic(p0: int, p1: int, p2: int, p3: int, t: int) -> int {
+    let m0: int = lerp(p0, p1, t);
+    let m1: int = lerp(p1, p2, t);
+    let m2: int = lerp(p2, p3, t);
+    let n0: int = lerp(m0, m1, t);
+    let n1: int = lerp(m1, m2, t);
+    return lerp(n0, n1, t);
+}
+
+// ─── Category 4: Fractals 🤯 ─────────────────────────────────────────────────
+
+// Mandelbrot set iteration count.
+//
+// cx, cy: fixed-point coordinates of the complex number c = cx/1000 + i*cy/1000
+//   cx = -2000..1000  (i.e. real part -2.0..1.0)
+//   cy = -1000..1000  (imaginary part -1.0..1.0)
+//
+// Returns the number of iterations before |z| > 2 (escape), or max_iter if
+// the point is in the Mandelbrot set.  Use the return value to colour blocks!
+//
+// Points in the set: mandelbrot_iter(-1000, 0, 100) == 100  (c = -1+0i)
+// Points outside:   mandelbrot_iter(1000, 0, 100)  == 0   (c = 1+0i, escapes immediately)
+// Boundary region:  mandelbrot_iter(-500, 500, 50) → varies
+//
+// Algorithm: z₀ = 0, z_{n+1} = z_n² + c
+//   z_n = (zr + zi·i),  z_n² = zr²−zi² + 2·zr·zi·i
+//   Escape when |z|² = (zr²+zi²)/10⁶ > 4  ↔  mulfix(zr,zr)+mulfix(zi,zi) > 4000
+fn mandelbrot_iter(cx: int, cy: int, max_iter: int) -> int {
+    let zr: int = 0;
+    let zi: int = 0;
+    let i: int = 0;
+    while (i < max_iter) {
+        let zr2: int = mulfix(zr, zr) - mulfix(zi, zi) + cx;
+        let zi2: int = 2 * mulfix(zr, zi) + cy;
+        zr = zr2;
+        zi = zi2;
+        if (mulfix(zr, zr) + mulfix(zi, zi) > 4000) {
+            return i;
+        }
+        i = i + 1;
+    }
+    return max_iter;
+}
+
+// Julia set iteration count (generalised Mandelbrot with fixed c and variable z₀).
+// z0r, z0i: starting point (fixed-point, scale=1000)
+// cr, ci:   constant c   (fixed-point, scale=1000)
+// Same escape condition as mandelbrot_iter.
+fn julia_iter(z0r: int, z0i: int, cr: int, ci: int, max_iter: int) -> int {
+    let zr: int = z0r;
+    let zi: int = z0i;
+    let i: int = 0;
+    while (i < max_iter) {
+        let zr2: int = mulfix(zr, zr) - mulfix(zi, zi) + cr;
+        let zi2: int = 2 * mulfix(zr, zi) + ci;
+        zr = zr2;
+        zi = zi2;
+        if (mulfix(zr, zr) + mulfix(zi, zi) > 4000) {
+            return i;
+        }
+        i = i + 1;
+    }
+    return max_iter;
+}