feat: Enhance constant folding and optimization in JavaScript and GLSL targets

- Implemented constant folding for various arithmetic operations in JavaScript target, including Add, Multiply, and Power functions.
- Added support for Mandelbrot and Julia set functions in JavaScript target.
- Optimized mathematical functions (Ceil, Floor, Round, Truncate) to bypass unnecessary computations for integer inputs.
- Updated GLSL and WGSL compilation to use direct multiplication for squares instead of pow function.
- Refactored complex number handling, renaming functions from Re, Im, Arg to Real, Imaginary, Argument for clarity.
- Introduced comprehensive tests for constant folding utilities and GPU handler optimizations.
- Improved error handling in ComputeEngine for unexpected values.

Author: arnog

CHANGELOG.md

@@ -1,3 +1,46 @@
+### [Unreleased]
+
+#### Improved
+
+- **Compilation: constant folding** — `Add`, `Multiply`, `Subtract`, `Negate`,
+  `Divide`, `Power`, `Sqrt`, and `Root` handlers now fold numeric literals at
+  compile time and eliminate identity values.
+  - `x + yi` compiles to `vec2(x, y)` instead of
+    `vec2(x, 0.0) + (y * vec2(0.0, 1.0))`
+  - `2 + 3` → `5.0`, `x + 0` → `x`, `x * 1` → `x`, `x * 0` → `0.0`
+  - `Power(x, 2)` → `(x * x)` for simple operands, `pow(f(x), 2.0)` for complex
+    expressions to avoid duplicate computation
+  - `Power(x, 0.5)` → `sqrt(x)`, `Power(x, 0)` → `1.0`, `Power(x, -1)` →
+    `(1.0 / x)`
+  - `Sqrt(4)` → `2.0`, `Root(x, 2)` → `sqrt(x)`
+- **`isComplexValued`** uses expression type system instead of hard-coded
+  operator list.
+- **Integer arguments** in GPU fractal functions emit as `200` instead of
+  `int(200.0)`.
+- **Type-based optimizations** — compilation handlers now use expression type
+  information for better code generation:
+  - `Floor`/`Ceil`/`Round`/`Truncate` are no-ops when the operand is
+    integer-typed
+  - `Abs` is a no-op when the operand is provably non-negative
+  - `Power(x, 2)` only expands to `(x * x)` for simple operands (symbols,
+    literals) — function calls like `Power(Sin(x), 2)` use `pow`/`Math.pow`
+    to avoid duplicate evaluation
+  - Integer `Mod` with non-negative dividend uses plain `%` instead of the
+    Euclidean double-mod formula
+  - GPU variable declarations infer `i32`/`int` type for integer-typed locals
+
+#### Fixed
+
+- **`Abs` signature**: return type is now `real` instead of propagating the
+  input type (which incorrectly returned `complex` for complex inputs).
+- **Compilation fallback**: uses `pushScope`/`assign` pattern instead of
+  crashing when receiving a vars object.
+
+#### Added
+
+- **`Mandelbrot` and `Julia`** operators in JavaScript and GPU compilation
+  targets.
+
 ### 0.55.2 _2026-03-04_
 
 #### Fixed
@@ -12,9 +55,9 @@
   symbol validation.
 - **`Text` operator type**: The `Text` operator now has return type `string`
   instead of `expression`.
-- **`\textcolor` inside `\text{}`**: `\textcolor{red}{RED}` inside `\text{}`
-  now correctly parses the body as text (`'RED'`) instead of switching to math
-  mode and treating each letter as a separate symbol.
+- **`\textcolor` inside `\text{}`**: `\textcolor{red}{RED}` inside `\text{}` now
+  correctly parses the body as text (`'RED'`) instead of switching to math mode
+  and treating each letter as a separate symbol.
 - **`parseSyntaxError` token consumption**: Non-command tokens (like `#`, `&`)
   are now consumed when producing errors, preventing potential parser loops.
 - **`parseSymbolToken` hardening**: Raw tokens are pre-validated against

docs/plans/2026-03-05-constant-folding-design.md

@@ -0,0 +1,125 @@
+# Constant Folding for Compilation Targets
+
+## Problem
+
+The GPU compiler emits redundant code for complex number construction and
+real arithmetic. For example, `x + yi` compiles to
+`vec2(x, 0.0) + (y * vec2(0.0, 1.0))` instead of `vec2(x, y)`.
+
+## Approach
+
+Add helper utilities for constant inspection and term folding, then update
+the `GPU_FUNCTIONS` handlers to use them. Folding happens at compile time
+by inspecting the expression tree — no string-level peephole passes.
+
+## Helper Utilities
+
+New file: `src/compute-engine/compilation/constant-folding.ts`
+
+### `tryGetConstant(expr: Expression): number | undefined`
+
+Returns a compile-time numeric constant if the expression is a literal
+number (integer, rational, float). Returns `undefined` for symbols,
+function expressions, or non-finite values.
+
+### `tryGetComplexParts(expr, compile, target): { re: string | null, im: string | null }`
+
+Decomposes an expression into real and imaginary code-string contributions.
+`null` means zero (no contribution to that component).
+
+Patterns handled:
+- `Complex(a, b)` with constant parts
+- `ImaginaryUnit` -> `{ re: null, im: "1.0" }`
+- `Multiply(k, ImaginaryUnit)` -> `{ re: null, im: compiled(k) }`
+- `Multiply(...reals, ImaginaryUnit, ...reals)` -> separate real product as im
+- Plain real expr -> `{ re: compiled, im: null }`
+
+### `foldTerms(terms: string[], identity: string, op: '+' | '*'): string`
+
+Combines compiled string terms with an operator:
+- Folds numeric literals (`"2.0" + "3.0"` -> `"5.0"`)
+- Eliminates identities (`x + 0.0` -> `x`, `x * 1.0` -> `x`)
+- Handles absorbing elements (`x * 0.0` -> `0.0`)
+- Returns identity for empty array, term itself for single-element
+
+## Handler Changes (gpu-target.ts)
+
+### Add
+
+1. No complex operands: use `foldTerms` on compiled real terms.
+2. Complex operands: partition all operands into real/imaginary contributions
+   via `tryGetComplexParts`, collect parts, fold each with `foldTerms`,
+   emit `vec2(realSum, imagSum)`.
+
+### Multiply
+
+1. Real-only: use `foldTerms` for constant folding and identity elimination.
+2. `Multiply(scalar, ImaginaryUnit)`: emit `vec2(0.0, scalar)` directly.
+3. `Multiply(scalars..., complexExpr)`: fold scalar part first, then
+   scalar-multiply the complex expression.
+
+### Negate
+
+- `Negate(Complex(a,b))`: emit `vec2(-a, -b)`.
+- `Negate(constant)`: fold to negated constant.
+- `Negate(ImaginaryUnit)`: emit `vec2(0.0, -1.0)`.
+
+### Divide
+
+- `Divide(constant, constant)`: fold to result.
+- `Divide(a, constant)`: fold constant divisor.
+- Complex path unchanged (uses `_gpu_cdiv`).
+
+### Power
+
+- `Power(x, 0)` -> `1.0`
+- `Power(x, 1)` -> `x`
+- `Power(x, 2)` -> `(x * x)`
+- `Power(x, -1)` -> `(1.0 / x)`
+- `Power(x, 0.5)` -> `sqrt(x)`
+- `Power(constant, constant)` -> fold to result.
+
+### Sqrt
+
+- `Sqrt(constant)` -> fold to result.
+- `Sqrt(0)` -> `0.0`, `Sqrt(1)` -> `1.0`.
+
+### Root
+
+- `Root(x, 2)` -> `sqrt(x)`.
+- `Root(constant, constant)` -> fold to result.
+
+## Testing
+
+New file: `test/compute-engine/compile-constant-folding.test.ts`
+
+### vec2 construction
+- `x + yi` -> `vec2(x, y)`
+- `x + 3i` -> `vec2(x, 3.0)`
+- `2x + 3yi` -> `vec2(2.0 * x, 3.0 * y)`
+- `3 + 4i` -> `vec2(3.0, 4.0)` (already works)
+- `0 + yi` -> `vec2(0.0, y)`
+
+### Real folding
+- `2 + 3` -> `5.0`
+- `x + 0` -> `x`
+- `x * 1` -> `x`
+- `x * 0` -> `0.0`
+- `(2 + 3) * x` -> `5.0 * x`
+
+### Identity elimination
+- `Power(x, 0)` -> `1.0`
+- `Power(x, 1)` -> `x`
+- `Sqrt(4)` -> `2.0`
+- `Divide(6, 3)` -> `2.0`
+
+### Operator-specific
+- `Negate(Complex(3, 4))` -> `vec2(-3.0, -4.0)`
+- `Power(x, 2)` -> `(x * x)`
+- `Root(x, 2)` -> `sqrt(x)`
+
+## Scope
+
+- Primary target: GPU (GLSL/WGSL)
+- Helpers are target-agnostic so JS target can adopt them later
+- No changes to expression canonicalization or simplification