@cortex-js/compute-engine 0.55.5 → 0.56.0

package/dist/types/compute-engine/compilation/glsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

package/dist/types/compute-engine/compilation/gpu-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -108,45 +108,6 @@ export declare const GPU_BESSELJ_PREAMBLE_GLSL = "\nfloat _gpu_factorial(int n)
  * GPU Bessel J function preamble (WGSL syntax).
  */
 export declare const GPU_BESSELJ_PREAMBLE_WGSL = "\nfn _gpu_factorial(n: i32) -> f32 {\n  var f: f32 = 1.0;\n  for (var i: i32 = 2; i <= n; i++) { f *= f32(i); }\n  return f;\n}\n\nfn _gpu_besselJ_series(n_in: i32, x: f32) -> f32 {\n  let halfX = x / 2.0;\n  let negQ = -(x * x) / 4.0;\n  var term: f32 = 1.0;\n  for (var i: i32 = 1; i <= n_in; i++) { term /= f32(i); }\n  var s = term;\n  for (var k: i32 = 1; k <= 60; k++) {\n    term *= negQ / (f32(k) * f32(n_in + k));\n    s += term;\n    if (abs(term) < abs(s) * 1e-7) { break; }\n  }\n  return s * pow(halfX, f32(n_in));\n}\n\nfn _gpu_besselJ_asymptotic(n_in: i32, x: f32) -> f32 {\n  let mu = 4.0 * f32(n_in) * f32(n_in);\n  var P: f32 = 1.0;\n  var Q: f32 = 0.0;\n  var ak: f32 = 1.0;\n  let e8x = 8.0 * x;\n  for (var k: i32 = 1; k <= 12; k++) {\n    let twokm1 = f32(2 * k - 1);\n    ak *= mu - twokm1 * twokm1;\n    let denom = _gpu_factorial(k) * pow(e8x, f32(k));\n    let contrib = ak / denom;\n    if (k == 1 || k == 3 || k == 5 || k == 7 || k == 9 || k == 11) {\n      if (((k - 1) / 2) % 2 == 0) { Q += contrib; }\n      else { Q -= contrib; }\n    } else {\n      if ((k / 2) % 2 == 1) { P -= contrib; }\n      else { P += contrib; }\n    }\n    if (abs(contrib) < 1e-7) { break; }\n  }\n  let chi = x - (f32(n_in) / 2.0 + 0.25) * 3.14159265358979;\n  return sqrt(2.0 / (3.14159265358979 * x)) * (P * cos(chi) - Q * sin(chi));\n}\n\nfn _gpu_besselJ(n_in: i32, x_in: f32) -> f32 {\n  var n = n_in;\n  var x = x_in;\n  if (x == 0.0) { return select(0.0, 1.0, n == 0); }\n  var sgn: f32 = 1.0;\n  if (n < 0) {\n    n = -n;\n    if (n % 2 != 0) { sgn = -1.0; }\n  }\n  if (x < 0.0) {\n    x = -x;\n    if (n % 2 != 0) { sgn *= -1.0; }\n  }\n  if (x > 25.0 + f32(n * n) / 2.0) { return sgn * _gpu_besselJ_asymptotic(n, x); }\n  if (x < 5.0 + f32(n)) { return sgn * _gpu_besselJ_series(n, x); }\n  // Miller's backward recurrence\n  var M = max(n + 20, i32(ceil(x)) + 30);\n  if (M > 200) { return sgn * _gpu_besselJ_series(n, x); }\n  var vals: array<f32, 201>;\n  var jp1: f32 = 0.0;\n  var jk: f32 = 1.0;\n  vals[M] = jk;\n  for (var k: i32 = M; k >= 1; k--) {\n    let jm1 = (2.0 * f32(k) / x) * jk - jp1;\n    jp1 = jk;\n    jk = jm1;\n    vals[k - 1] = jk;\n  }\n  var norm = vals[0];\n  for (var k2: i32 = 2; k2 <= M; k2 += 2) { norm += 2.0 * vals[k2]; }\n  return sgn * vals[n] / norm;\n}\n";
-/**
- * Double-single (DS) emulated double-precision arithmetic preamble (GLSL).
- *
- * A "double-single" number is stored as vec2(hi, lo) where value = hi + lo,
- * giving ~48 bits of mantissa from two 32-bit floats.
- * Algorithms: Dekker (1971) / Knuth (1997).
- */
-export declare const GPU_DS_ARITHMETIC_PREAMBLE_GLSL = "\n// Split a float into high and low parts for exact multiplication\nvec2 ds_split(float a) {\n  const float SPLIT = 4097.0; // 2^12 + 1\n  float t = SPLIT * a;\n  float hi = t - (t - a);\n  float lo = a - hi;\n  return vec2(hi, lo);\n}\n\n// Create a double-single from a single float\nvec2 ds_from(float a) {\n  return vec2(a, 0.0);\n}\n\n// Error-free addition (Knuth TwoSum)\nvec2 ds_add(vec2 a, vec2 b) {\n  float s = a.x + b.x;\n  float v = s - a.x;\n  float e = (a.x - (s - v)) + (b.x - v);\n  float lo = (a.y + b.y) + e;\n  float hi = s + lo;\n  lo = lo - (hi - s);\n  return vec2(hi, lo);\n}\n\n// Double-single subtraction\nvec2 ds_sub(vec2 a, vec2 b) {\n  return ds_add(a, vec2(-b.x, -b.y));\n}\n\n// Error-free multiplication (Dekker TwoProduct)\nvec2 ds_mul(vec2 a, vec2 b) {\n  float p = a.x * b.x;\n  vec2 sa = ds_split(a.x);\n  vec2 sb = ds_split(b.x);\n  float err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;\n  err += a.x * b.y + a.y * b.x;\n  float hi = p + err;\n  float lo = err - (hi - p);\n  return vec2(hi, lo);\n}\n\n// Optimized self-multiply\nvec2 ds_sqr(vec2 a) {\n  float p = a.x * a.x;\n  vec2 sa = ds_split(a.x);\n  float err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;\n  err += 2.0 * a.x * a.y;\n  float hi = p + err;\n  float lo = err - (hi - p);\n  return vec2(hi, lo);\n}\n\n// Compare magnitude: returns -1, 0, or 1\nfloat ds_cmp(vec2 a, vec2 b) {\n  float d = a.x - b.x;\n  if (d != 0.0) return sign(d);\n  return sign(a.y - b.y);\n}\n";
-/**
- * Double-single (DS) emulated double-precision arithmetic preamble (WGSL).
- *
- * A "double-single" number is stored as vec2f(hi, lo) where value = hi + lo,
- * giving ~48 bits of mantissa from two 32-bit floats.
- * Algorithms: Dekker (1971) / Knuth (1997).
- */
-export declare const GPU_DS_ARITHMETIC_PREAMBLE_WGSL = "\nfn ds_split(a: f32) -> vec2f {\n  const SPLIT: f32 = 4097.0;\n  let t = SPLIT * a;\n  let hi = t - (t - a);\n  let lo = a - hi;\n  return vec2f(hi, lo);\n}\n\nfn ds_from(a: f32) -> vec2f {\n  return vec2f(a, 0.0);\n}\n\nfn ds_add(a: vec2f, b: vec2f) -> vec2f {\n  let s = a.x + b.x;\n  let v = s - a.x;\n  let e = (a.x - (s - v)) + (b.x - v);\n  let lo_t = (a.y + b.y) + e;\n  let hi = s + lo_t;\n  let lo = lo_t - (hi - s);\n  return vec2f(hi, lo);\n}\n\nfn ds_sub(a: vec2f, b: vec2f) -> vec2f {\n  return ds_add(a, vec2f(-b.x, -b.y));\n}\n\nfn ds_mul(a: vec2f, b: vec2f) -> vec2f {\n  let p = a.x * b.x;\n  let sa = ds_split(a.x);\n  let sb = ds_split(b.x);\n  var err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;\n  err += a.x * b.y + a.y * b.x;\n  let hi = p + err;\n  let lo = err - (hi - p);\n  return vec2f(hi, lo);\n}\n\nfn ds_sqr(a: vec2f) -> vec2f {\n  let p = a.x * a.x;\n  let sa = ds_split(a.x);\n  var err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;\n  err += 2.0 * a.x * a.y;\n  let hi = p + err;\n  let lo = err - (hi - p);\n  return vec2f(hi, lo);\n}\n\nfn ds_cmp(a: vec2f, b: vec2f) -> f32 {\n  let d = a.x - b.x;\n  if (d != 0.0) { return sign(d); }\n  return sign(a.y - b.y);\n}\n";
-/**
- * Double-precision fractal preamble (GLSL syntax).
- *
- * Emulated double-precision (double-single) Mandelbrot and Julia iterations.
- * Complex numbers are packed as vec4(re_hi, im_hi, re_lo, im_lo).
- * Requires GPU_DS_ARITHMETIC_PREAMBLE_GLSL to be included first.
- *
- * Coordinate computation:
- * The shader template provides single-precision x,y via mix(), which lose
- * distinguishability at deep zoom. Instead, _dp_coord() computes coordinates
- * from the viewport UV (v_uv) and center/size uniforms. The per-pixel delta
- * from center is small enough for float to distinguish adjacent pixels, and
- * ds_add combines it with the center for ~48-bit total precision.
- */
-export declare const GPU_FRACTAL_DP_PREAMBLE_GLSL = "\nuniform float _dp_cx_hi;\nuniform float _dp_cx_lo;\nuniform float _dp_cy_hi;\nuniform float _dp_cy_lo;\nuniform float _dp_w;\nuniform float _dp_h;\n\nvec4 _dp_coord() {\n  // Per-pixel offset from center \u2014 small, so float-precise\n  float dx = (v_uv.x - 0.5) * _dp_w;\n  float dy = (v_uv.y - 0.5) * _dp_h;\n  // Combine center (hi+lo) + delta with emulated double precision\n  vec2 cre = ds_add(vec2(_dp_cx_hi, _dp_cx_lo), ds_from(dx));\n  vec2 cim = ds_add(vec2(_dp_cy_hi, _dp_cy_lo), ds_from(dy));\n  return vec4(cre.x, cim.x, cre.y, cim.y);\n}\n\nfloat _fractal_mandelbrot_dp(vec4 c, int maxIter) {\n  // c = (re_hi, im_hi, re_lo, im_lo)\n  vec2 cr = vec2(c.x, c.z);  // real part as ds\n  vec2 ci = vec2(c.y, c.w);  // imag part as ds\n  vec2 zr = vec2(0.0, 0.0);\n  vec2 zi = vec2(0.0, 0.0);\n  for (int i = 0; i < maxIter; i++) {\n    vec2 zr2 = ds_sqr(zr);\n    vec2 zi2 = ds_sqr(zi);\n    // |z|^2 > 4.0 ?\n    vec2 mag2 = ds_add(zr2, zi2);\n    if (mag2.x > 4.0)\n      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);\n    // z = z^2 + c\n    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci); // 2*zr*zi + ci\n    zr = ds_add(ds_sub(zr2, zi2), cr);                    // zr^2 - zi^2 + cr\n    zi = new_zi;\n  }\n  return 1.0;\n}\n\nfloat _fractal_julia_dp(vec4 z_in, vec4 c, int maxIter) {\n  vec2 zr = vec2(z_in.x, z_in.z);\n  vec2 zi = vec2(z_in.y, z_in.w);\n  vec2 cr = vec2(c.x, c.z);\n  vec2 ci = vec2(c.y, c.w);\n  for (int i = 0; i < maxIter; i++) {\n    vec2 zr2 = ds_sqr(zr);\n    vec2 zi2 = ds_sqr(zi);\n    vec2 mag2 = ds_add(zr2, zi2);\n    if (mag2.x > 4.0)\n      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);\n    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);\n    zr = ds_add(ds_sub(zr2, zi2), cr);\n    zi = new_zi;\n  }\n  return 1.0;\n}\n";
-/**
- * Double-precision fractal preamble (WGSL syntax).
- *
- * Emulated double-precision (double-single) Mandelbrot and Julia iterations.
- * Complex numbers are packed as vec4f(re_hi, im_hi, re_lo, im_lo).
- * Requires GPU_DS_ARITHMETIC_PREAMBLE_WGSL to be included first.
- */
-export declare const GPU_FRACTAL_DP_PREAMBLE_WGSL = "\n@group(0) @binding(10) var<uniform> _dp_cx_hi: f32;\n@group(0) @binding(11) var<uniform> _dp_cx_lo: f32;\n@group(0) @binding(12) var<uniform> _dp_cy_hi: f32;\n@group(0) @binding(13) var<uniform> _dp_cy_lo: f32;\n@group(0) @binding(14) var<uniform> _dp_w: f32;\n@group(0) @binding(15) var<uniform> _dp_h: f32;\n\nfn _dp_coord(uv: vec2f) -> vec4f {\n  let dx = (uv.x - 0.5) * _dp_w;\n  let dy = (uv.y - 0.5) * _dp_h;\n  let cre = ds_add(vec2f(_dp_cx_hi, _dp_cx_lo), ds_from(dx));\n  let cim = ds_add(vec2f(_dp_cy_hi, _dp_cy_lo), ds_from(dy));\n  return vec4f(cre.x, cim.x, cre.y, cim.y);\n}\n\nfn _fractal_mandelbrot_dp(c: vec4f, maxIter: i32) -> f32 {\n  let cr = vec2f(c.x, c.z);\n  let ci = vec2f(c.y, c.w);\n  var zr = vec2f(0.0, 0.0);\n  var zi = vec2f(0.0, 0.0);\n  for (var i: i32 = 0; i < maxIter; i++) {\n    let zr2 = ds_sqr(zr);\n    let zi2 = ds_sqr(zi);\n    let mag2 = ds_add(zr2, zi2);\n    if (mag2.x > 4.0) {\n      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);\n    zr = ds_add(ds_sub(zr2, zi2), cr);\n    zi = new_zi;\n  }\n  return 1.0;\n}\n\nfn _fractal_julia_dp(z_in: vec4f, c: vec4f, maxIter: i32) -> f32 {\n  var zr = vec2f(z_in.x, z_in.z);\n  var zi = vec2f(z_in.y, z_in.w);\n  let cr = vec2f(c.x, c.z);\n  let ci = vec2f(c.y, c.w);\n  for (var i: i32 = 0; i < maxIter; i++) {\n    let zr2 = ds_sqr(zr);\n    let zi2 = ds_sqr(zi);\n    let mag2 = ds_add(zr2, zi2);\n    if (mag2.x > 4.0) {\n      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);\n    zr = ds_add(ds_sub(zr2, zi2), cr);\n    zi = new_zi;\n  }\n  return 1.0;\n}\n";
 /**
  * Fractal preamble (GLSL syntax).
  *
@@ -159,33 +120,29 @@ export declare const GPU_FRACTAL_PREAMBLE_GLSL = "\nfloat _fractal_mandelbrot(ve
  * Fractal preamble (WGSL syntax).
  */
 export declare const GPU_FRACTAL_PREAMBLE_WGSL = "\nfn _fractal_mandelbrot(c: vec2f, maxIter: i32) -> f32 {\n  var z = vec2f(0.0, 0.0);\n  for (var i: i32 = 0; i < maxIter; i++) {\n    z = vec2f(z.x*z.x - z.y*z.y + c.x, 2.0*z.x*z.y + c.y);\n    if (dot(z, z) > 4.0) {\n      return clamp((f32(i) - log2(log2(dot(z, z))) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n  }\n  return 1.0;\n}\n\nfn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {\n  var z = z_in;\n  for (var i: i32 = 0; i < maxIter; i++) {\n    z = vec2f(z.x*z.x - z.y*z.y + c.x, 2.0*z.x*z.y + c.y);\n    if (dot(z, z) > 4.0) {\n      return clamp((f32(i) - log2(log2(dot(z, z))) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n  }\n  return 1.0;\n}\n";
-/**
- * Perturbation-theory fractal preamble (GLSL syntax).
- *
- * Provides `_fractal_mandelbrot_pt` and `_fractal_julia_pt` which iterate
- * a perturbation delta relative to a precomputed reference orbit stored in
- * a RG32F texture. Includes glitch detection with single-float fallback.
- */
-export declare const GPU_FRACTAL_PT_PREAMBLE_GLSL = "\nuniform sampler2D _refOrbit;\nuniform int _refOrbitLen;\nuniform int _refOrbitTexWidth;\nuniform float _pt_offset_x;\nuniform float _pt_offset_y;\nuniform float _pt_w;\nuniform float _pt_h;\n\nvec2 _pt_delta() {\n  float dx = _pt_offset_x + (v_uv.x - 0.5) * _pt_w;\n  float dy = _pt_offset_y + (v_uv.y - 0.5) * _pt_h;\n  return vec2(dx, dy);\n}\n\nvec2 _pt_fetch_orbit(int i) {\n  int y = i / _refOrbitTexWidth;\n  int x = i - y * _refOrbitTexWidth;\n  return texelFetch(_refOrbit, ivec2(x, y), 0).rg;\n}\n\nfloat _fractal_mandelbrot_pt(vec2 delta_c, int maxIter) {\n  float dr = 0.0;\n  float di = 0.0;\n  int orbitLen = min(maxIter, _refOrbitLen);\n  for (int i = 0; i < orbitLen; i++) {\n    vec2 Zn = _pt_fetch_orbit(i);\n    // delta_{n+1} = 2*Z_n*delta_n + delta_n^2 + delta_c\n    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;\n    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;\n    dr = new_dr;\n    di = new_di;\n    // Full z = Z_{n+1} + delta for escape check\n    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);\n    float zr = Zn1.x + dr;\n    float zi = Zn1.y + di;\n    float mag2 = zr * zr + zi * zi;\n    if (mag2 > 4.0)\n      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);\n    // Glitch detection: |delta|^2 > |Z|^2\n    float dmag2 = dr * dr + di * di;\n    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;\n    if (dmag2 > Zmag2 && Zmag2 > 0.0) {\n      // Rebase to absolute coordinates and continue with single-float\n      float abs_zr = Zn1.x + dr;\n      float abs_zi = Zn1.y + di;\n      // Reconstruct absolute c from reference + delta\n      // (Use ds_from for the concept, but single-float suffices for fallback)\n      float cx = abs_zr - dr + delta_c.x;\n      float cy = abs_zi - di + delta_c.y;\n      for (int j = i + 1; j < maxIter; j++) {\n        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;\n        abs_zi = 2.0 * abs_zr * abs_zi + cy;\n        abs_zr = new_zr;\n        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;\n        if (mag2 > 4.0)\n          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);\n      }\n      return 1.0;\n    }\n  }\n  return 1.0;\n}\n\nfloat _fractal_julia_pt(vec2 z_delta, vec2 delta_c, int maxIter) {\n  float dr = z_delta.x;\n  float di = z_delta.y;\n  int orbitLen = min(maxIter, _refOrbitLen);\n  for (int i = 0; i < orbitLen; i++) {\n    vec2 Zn = _pt_fetch_orbit(i);\n    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;\n    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;\n    dr = new_dr;\n    di = new_di;\n    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);\n    float zr = Zn1.x + dr;\n    float zi = Zn1.y + di;\n    float mag2 = zr * zr + zi * zi;\n    if (mag2 > 4.0)\n      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);\n    float dmag2 = dr * dr + di * di;\n    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;\n    if (dmag2 > Zmag2 && Zmag2 > 0.0) {\n      float abs_zr = Zn1.x + dr;\n      float abs_zi = Zn1.y + di;\n      float cx = delta_c.x;\n      float cy = delta_c.y;\n      for (int j = i + 1; j < maxIter; j++) {\n        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;\n        abs_zi = 2.0 * abs_zr * abs_zi + cy;\n        abs_zr = new_zr;\n        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;\n        if (mag2 > 4.0)\n          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);\n      }\n      return 1.0;\n    }\n  }\n  return 1.0;\n}\n";
-/**
- * Perturbation-theory fractal preamble (WGSL syntax).
- *
- * Same logic as the GLSL version, adapted for WGSL syntax.
- */
-export declare const GPU_FRACTAL_PT_PREAMBLE_WGSL = "\n@group(0) @binding(1) var _refOrbit: texture_2d<f32>;\nvar<uniform> _refOrbitLen: i32;\nvar<uniform> _refOrbitTexWidth: i32;\nvar<uniform> _pt_offset_x: f32;\nvar<uniform> _pt_offset_y: f32;\nvar<uniform> _pt_w: f32;\nvar<uniform> _pt_h: f32;\n\nfn _pt_delta(uv: vec2f) -> vec2f {\n  let dx = _pt_offset_x + (uv.x - 0.5) * _pt_w;\n  let dy = _pt_offset_y + (uv.y - 0.5) * _pt_h;\n  return vec2f(dx, dy);\n}\n\nfn _pt_fetch_orbit(i: i32) -> vec2f {\n  let y = i / _refOrbitTexWidth;\n  let x = i - y * _refOrbitTexWidth;\n  return textureLoad(_refOrbit, vec2i(x, y), 0).rg;\n}\n\nfn _fractal_mandelbrot_pt(delta_c: vec2f, maxIter: i32) -> f32 {\n  var dr: f32 = 0.0;\n  var di: f32 = 0.0;\n  let orbitLen = min(maxIter, _refOrbitLen);\n  for (var i: i32 = 0; i < orbitLen; i++) {\n    let Zn = _pt_fetch_orbit(i);\n    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;\n    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;\n    dr = new_dr;\n    di = new_di;\n    var Zn1 = vec2f(0.0);\n    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }\n    let zr = Zn1.x + dr;\n    let zi = Zn1.y + di;\n    var mag2 = zr * zr + zi * zi;\n    if (mag2 > 4.0) {\n      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n    let dmag2 = dr * dr + di * di;\n    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;\n    if (dmag2 > Zmag2 && Zmag2 > 0.0) {\n      var f_zr = Zn1.x + dr;\n      var f_zi = Zn1.y + di;\n      let cx = delta_c.x;\n      let cy = delta_c.y;\n      for (var j: i32 = i + 1; j < maxIter; j++) {\n        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;\n        f_zi = 2.0 * f_zr * f_zi + cy;\n        f_zr = t_zr;\n        mag2 = f_zr * f_zr + f_zi * f_zi;\n        if (mag2 > 4.0) {\n          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);\n        }\n      }\n      return 1.0;\n    }\n  }\n  return 1.0;\n}\n\nfn _fractal_julia_pt(z_delta: vec2f, delta_c: vec2f, maxIter: i32) -> f32 {\n  var dr = z_delta.x;\n  var di = z_delta.y;\n  let orbitLen = min(maxIter, _refOrbitLen);\n  for (var i: i32 = 0; i < orbitLen; i++) {\n    let Zn = _pt_fetch_orbit(i);\n    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;\n    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;\n    dr = new_dr;\n    di = new_di;\n    var Zn1 = vec2f(0.0);\n    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }\n    let zr = Zn1.x + dr;\n    let zi = Zn1.y + di;\n    var mag2 = zr * zr + zi * zi;\n    if (mag2 > 4.0) {\n      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n    let dmag2 = dr * dr + di * di;\n    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;\n    if (dmag2 > Zmag2 && Zmag2 > 0.0) {\n      var f_zr = Zn1.x + dr;\n      var f_zi = Zn1.y + di;\n      let cx = delta_c.x;\n      let cy = delta_c.y;\n      for (var j: i32 = i + 1; j < maxIter; j++) {\n        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;\n        f_zi = 2.0 * f_zr * f_zi + cy;\n        f_zr = t_zr;\n        mag2 = f_zr * f_zr + f_zi * f_zi;\n        if (mag2 > 4.0) {\n          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);\n        }\n      }\n      return 1.0;\n    }\n  }\n  return 1.0;\n}\n";
 /**
  * GPU color space conversion preamble (GLSL syntax).
  *
- * Provides sRGB ↔ OKLab ↔ OKLCh conversions, color mixing in OKLCh
- * with shorter-arc hue interpolation, and APCA contrast calculation.
+ * Canonical color value: vec3 OKLCh `(L, C, H_deg)` — same convention as the
+ * interpreted/JS-runtime layer. Shaders that write to a sRGB framebuffer must
+ * wrap the final color in `_gpu_oklch_to_srgb()` at the boundary.
+ *
+ * Hue is in degrees throughout (matching the boxed-expression convention).
+ * `_gpu_color_mix` interpolates directly in OKLCh — no sRGB pinch — and
+ * special-cases achromatic endpoints (C ≈ 0) so e.g. mixing red with white
+ * preserves red's hue rather than drifting through arbitrary hues.
  *
  * WGSL targets must adapt syntax (vec3f, atan2→atan2, etc.).
  */
-export declare const GPU_COLOR_PREAMBLE_GLSL = "\nfloat _gpu_srgb_to_linear(float c) {\n  if (c <= 0.04045) return c / 12.92;\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfloat _gpu_linear_to_srgb(float c) {\n  if (c <= 0.0031308) return 12.92 * c;\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nvec3 _gpu_srgb_to_oklab(vec3 rgb) {\n  float r = _gpu_srgb_to_linear(rgb.x);\n  float g = _gpu_srgb_to_linear(rgb.y);\n  float b = _gpu_srgb_to_linear(rgb.z);\n  float l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  float m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  float s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nvec3 _gpu_oklab_to_srgb(vec3 lab) {\n  float l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  float m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  float s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  float l = l_ * l_ * l_;\n  float m = m_ * m_ * m_;\n  float s = s_ * s_ * s_;\n  float r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  float g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  float b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), 0.0, 1.0);\n}\n\nvec3 _gpu_oklab_to_oklch(vec3 lab) {\n  float C = length(lab.yz);\n  float H = atan(lab.z, lab.y);\n  return vec3(lab.x, C, H);\n}\n\nvec3 _gpu_oklch_to_oklab(vec3 lch) {\n  return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nvec3 _gpu_color_mix(vec3 rgb1, vec3 rgb2, float t) {\n  vec3 lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));\n  vec3 lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));\n  float L = mix(lch1.x, lch2.x, t);\n  float C = mix(lch1.y, lch2.y, t);\n  float dh = lch2.z - lch1.z;\n  const float PI = 3.14159265359;\n  if (dh > PI) dh -= 2.0 * PI;\n  if (dh < -PI) dh += 2.0 * PI;\n  float H = lch1.z + dh * t;\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3(L, C, H)));\n}\n\nfloat _gpu_apca(vec3 bg, vec3 fg) {\n  float bgR = _gpu_srgb_to_linear(bg.x);\n  float bgG = _gpu_srgb_to_linear(bg.y);\n  float bgB = _gpu_srgb_to_linear(bg.z);\n  float fgR = _gpu_srgb_to_linear(fg.x);\n  float fgG = _gpu_srgb_to_linear(fg.y);\n  float fgB = _gpu_srgb_to_linear(fg.z);\n  float bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  float fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  float bgC = pow(bgY, 0.56);\n  float fgC = pow(fgY, 0.57);\n  float contrast = (bgC > fgC)\n    ? (bgC - fgC) * 1.14\n    : (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
+export declare const GPU_COLOR_PREAMBLE_GLSL = "\nfloat _gpu_srgb_to_linear(float c) {\n  if (c <= 0.04045) return c / 12.92;\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfloat _gpu_linear_to_srgb(float c) {\n  if (c <= 0.0031308) return 12.92 * c;\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nvec3 _gpu_srgb_to_oklab(vec3 rgb) {\n  float r = _gpu_srgb_to_linear(rgb.x);\n  float g = _gpu_srgb_to_linear(rgb.y);\n  float b = _gpu_srgb_to_linear(rgb.z);\n  float l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  float m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  float s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nvec3 _gpu_oklab_to_srgb(vec3 lab) {\n  float l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  float m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  float s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  float l = l_ * l_ * l_;\n  float m = m_ * m_ * m_;\n  float s = s_ * s_ * s_;\n  float r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  float g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  float b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), 0.0, 1.0);\n}\n\nvec3 _gpu_oklab_to_oklch(vec3 lab) {\n  float C = length(lab.yz);\n  float H = atan(lab.z, lab.y) * (180.0 / 3.14159265359);\n  if (H < 0.0) H += 360.0;\n  return vec3(lab.x, C, H);\n}\n\nvec3 _gpu_oklch_to_oklab(vec3 lch) {\n  float h_rad = lch.z * (3.14159265359 / 180.0);\n  return vec3(lch.x, lch.y * cos(h_rad), lch.y * sin(h_rad));\n}\n\nvec3 _gpu_srgb_to_oklch(vec3 rgb) {\n  return _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb));\n}\n\nvec3 _gpu_oklch_to_srgb(vec3 lch) {\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(lch));\n}\n\n// HSL conversion. Hue in degrees, saturation/lightness in 0-1.\nvec3 _gpu_hsl_to_rgb(vec3 hsl) {\n  float h = hsl.x;\n  float s = hsl.y;\n  float l = hsl.z;\n  float c = (1.0 - abs(2.0 * l - 1.0)) * s;\n  float h6 = h / 60.0;\n  float x = c * (1.0 - abs(mod(h6, 2.0) - 1.0));\n  float r = 0.0;\n  float g = 0.0;\n  float b = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  float m = l - c / 2.0;\n  return vec3(r + m, g + m, b + m);\n}\n\nvec3 _gpu_rgb_to_hsl(vec3 rgb) {\n  float maxc = max(max(rgb.x, rgb.y), rgb.z);\n  float minc = min(min(rgb.x, rgb.y), rgb.z);\n  float l = (maxc + minc) / 2.0;\n  float d = maxc - minc;\n  if (d < 1e-6) return vec3(0.0, 0.0, l);\n  float s = d / (1.0 - abs(2.0 * l - 1.0));\n  float h;\n  if (maxc == rgb.x)      h = mod((rgb.y - rgb.z) / d, 6.0);\n  else if (maxc == rgb.y) h = (rgb.z - rgb.x) / d + 2.0;\n  else                    h = (rgb.x - rgb.y) / d + 4.0;\n  h *= 60.0;\n  if (h < 0.0) h += 360.0;\n  return vec3(h, s, l);\n}\n\n// HSV conversion. Hue in degrees, saturation/value in 0-1.\nvec3 _gpu_hsv_to_rgb(vec3 hsv) {\n  float h = hsv.x;\n  float s = hsv.y;\n  float v = hsv.z;\n  float c = v * s;\n  float h6 = h / 60.0;\n  float x = c * (1.0 - abs(mod(h6, 2.0) - 1.0));\n  float r = 0.0;\n  float g = 0.0;\n  float b = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  float m = v - c;\n  return vec3(r + m, g + m, b + m);\n}\n\nvec3 _gpu_rgb_to_hsv(vec3 rgb) {\n  float maxc = max(max(rgb.x, rgb.y), rgb.z);\n  float minc = min(min(rgb.x, rgb.y), rgb.z);\n  float v = maxc;\n  float d = maxc - minc;\n  if (d < 1e-6) return vec3(0.0, 0.0, v);\n  float s = (maxc < 1e-6) ? 0.0 : d / maxc;\n  float h;\n  if (maxc == rgb.x)      h = mod((rgb.y - rgb.z) / d, 6.0);\n  else if (maxc == rgb.y) h = (rgb.z - rgb.x) / d + 2.0;\n  else                    h = (rgb.x - rgb.y) / d + 4.0;\n  h *= 60.0;\n  if (h < 0.0) h += 360.0;\n  return vec3(h, s, v);\n}\n\nvec3 _gpu_color_mix(vec3 lch1, vec3 lch2, float t) {\n  float L = mix(lch1.x, lch2.x, t);\n  float C = mix(lch1.y, lch2.y, t);\n  bool a1 = lch1.y < 1e-6;\n  bool a2 = lch2.y < 1e-6;\n  float H;\n  if (a1 && a2) {\n    H = lch1.z;\n  } else if (a1) {\n    H = lch2.z;\n  } else if (a2) {\n    H = lch1.z;\n  } else {\n    float dh = lch2.z - lch1.z;\n    if (dh > 180.0) dh -= 360.0;\n    if (dh < -180.0) dh += 360.0;\n    H = lch1.z + dh * t;\n    if (H < 0.0) H += 360.0;\n    if (H >= 360.0) H -= 360.0;\n  }\n  return vec3(L, C, H);\n}\n\nfloat _gpu_apca(vec3 lch_bg, vec3 lch_fg) {\n  vec3 bg = _gpu_oklch_to_srgb(lch_bg);\n  vec3 fg = _gpu_oklch_to_srgb(lch_fg);\n  float bgR = _gpu_srgb_to_linear(bg.x);\n  float bgG = _gpu_srgb_to_linear(bg.y);\n  float bgB = _gpu_srgb_to_linear(bg.z);\n  float fgR = _gpu_srgb_to_linear(fg.x);\n  float fgG = _gpu_srgb_to_linear(fg.y);\n  float fgB = _gpu_srgb_to_linear(fg.z);\n  float bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  float fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  float bgC = pow(bgY, 0.56);\n  float fgC = pow(fgY, 0.57);\n  float contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
 /**
  * GPU color space conversion preamble (WGSL syntax).
+ *
+ * Same convention as the GLSL preamble: canonical color value is `vec3f`
+ * OKLCh `(L, C, H_deg)`. Shaders writing to a sRGB framebuffer must wrap
+ * their final color in `_gpu_oklch_to_srgb()`.
  */
-export declare const GPU_COLOR_PREAMBLE_WGSL = "\nfn _gpu_srgb_to_linear(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn _gpu_linear_to_srgb(c: f32) -> f32 {\n  if (c <= 0.0031308) { return 12.92 * c; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nfn _gpu_srgb_to_oklab(rgb: vec3f) -> vec3f {\n  let r = _gpu_srgb_to_linear(rgb.x);\n  let g = _gpu_srgb_to_linear(rgb.y);\n  let b = _gpu_srgb_to_linear(rgb.z);\n  let l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  let m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  let s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3f(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nfn _gpu_oklab_to_srgb(lab: vec3f) -> vec3f {\n  let l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  let m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  let s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  let l = l_ * l_ * l_;\n  let m = m_ * m_ * m_;\n  let s = s_ * s_ * s_;\n  let r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  let b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3f(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), vec3f(0.0), vec3f(1.0));\n}\n\nfn _gpu_oklab_to_oklch(lab: vec3f) -> vec3f {\n  let C = length(lab.yz);\n  let H = atan2(lab.z, lab.y);\n  return vec3f(lab.x, C, H);\n}\n\nfn _gpu_oklch_to_oklab(lch: vec3f) -> vec3f {\n  return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));\n}\n\nfn _gpu_color_mix(rgb1: vec3f, rgb2: vec3f, t: f32) -> vec3f {\n  let lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));\n  let lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));\n  let L = mix(lch1.x, lch2.x, t);\n  let C = mix(lch1.y, lch2.y, t);\n  let PI = 3.14159265359;\n  var dh = lch2.z - lch1.z;\n  if (dh > PI) { dh -= 2.0 * PI; }\n  if (dh < -PI) { dh += 2.0 * PI; }\n  let H = lch1.z + dh * t;\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3f(L, C, H)));\n}\n\nfn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {\n  let bgR = _gpu_srgb_to_linear(bg.x);\n  let bgG = _gpu_srgb_to_linear(bg.y);\n  let bgB = _gpu_srgb_to_linear(bg.z);\n  let fgR = _gpu_srgb_to_linear(fg.x);\n  let fgG = _gpu_srgb_to_linear(fg.y);\n  let fgB = _gpu_srgb_to_linear(fg.z);\n  let bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  let fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  let bgC = pow(bgY, 0.56);\n  let fgC = pow(fgY, 0.57);\n  let contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
+export declare const GPU_COLOR_PREAMBLE_WGSL = "\nfn _gpu_srgb_to_linear(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn _gpu_linear_to_srgb(c: f32) -> f32 {\n  if (c <= 0.0031308) { return 12.92 * c; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nfn _gpu_srgb_to_oklab(rgb: vec3f) -> vec3f {\n  let r = _gpu_srgb_to_linear(rgb.x);\n  let g = _gpu_srgb_to_linear(rgb.y);\n  let b = _gpu_srgb_to_linear(rgb.z);\n  let l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  let m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  let s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3f(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nfn _gpu_oklab_to_srgb(lab: vec3f) -> vec3f {\n  let l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  let m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  let s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  let l = l_ * l_ * l_;\n  let m = m_ * m_ * m_;\n  let s = s_ * s_ * s_;\n  let r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  let b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3f(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), vec3f(0.0), vec3f(1.0));\n}\n\nfn _gpu_oklab_to_oklch(lab: vec3f) -> vec3f {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y) * (180.0 / 3.14159265359);\n  if (H < 0.0) { H = H + 360.0; }\n  return vec3f(lab.x, C, H);\n}\n\nfn _gpu_oklch_to_oklab(lch: vec3f) -> vec3f {\n  let h_rad = lch.z * (3.14159265359 / 180.0);\n  return vec3f(lch.x, lch.y * cos(h_rad), lch.y * sin(h_rad));\n}\n\nfn _gpu_srgb_to_oklch(rgb: vec3f) -> vec3f {\n  return _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb));\n}\n\nfn _gpu_oklch_to_srgb(lch: vec3f) -> vec3f {\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(lch));\n}\n\nfn _gpu_hsl_to_rgb(hsl: vec3f) -> vec3f {\n  let h = hsl.x;\n  let s = hsl.y;\n  let l = hsl.z;\n  let c = (1.0 - abs(2.0 * l - 1.0)) * s;\n  let h6 = h / 60.0;\n  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));\n  var r: f32 = 0.0;\n  var g: f32 = 0.0;\n  var b: f32 = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  let m = l - c / 2.0;\n  return vec3f(r + m, g + m, b + m);\n}\n\nfn _gpu_rgb_to_hsl(rgb: vec3f) -> vec3f {\n  let maxc = max(max(rgb.x, rgb.y), rgb.z);\n  let minc = min(min(rgb.x, rgb.y), rgb.z);\n  let l = (maxc + minc) / 2.0;\n  let d = maxc - minc;\n  if (d < 1e-6) { return vec3f(0.0, 0.0, l); }\n  let s = d / (1.0 - abs(2.0 * l - 1.0));\n  var h: f32;\n  if (maxc == rgb.x) {\n    let v = (rgb.y - rgb.z) / d;\n    h = v - 6.0 * floor(v / 6.0);\n  } else if (maxc == rgb.y) {\n    h = (rgb.z - rgb.x) / d + 2.0;\n  } else {\n    h = (rgb.x - rgb.y) / d + 4.0;\n  }\n  h = h * 60.0;\n  if (h < 0.0) { h = h + 360.0; }\n  return vec3f(h, s, l);\n}\n\nfn _gpu_hsv_to_rgb(hsv: vec3f) -> vec3f {\n  let h = hsv.x;\n  let s = hsv.y;\n  let v = hsv.z;\n  let c = v * s;\n  let h6 = h / 60.0;\n  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));\n  var r: f32 = 0.0;\n  var g: f32 = 0.0;\n  var b: f32 = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  let m = v - c;\n  return vec3f(r + m, g + m, b + m);\n}\n\nfn _gpu_rgb_to_hsv(rgb: vec3f) -> vec3f {\n  let maxc = max(max(rgb.x, rgb.y), rgb.z);\n  let minc = min(min(rgb.x, rgb.y), rgb.z);\n  let v = maxc;\n  let d = maxc - minc;\n  if (d < 1e-6) { return vec3f(0.0, 0.0, v); }\n  var s: f32 = 0.0;\n  if (maxc >= 1e-6) { s = d / maxc; }\n  var h: f32;\n  if (maxc == rgb.x) {\n    let q = (rgb.y - rgb.z) / d;\n    h = q - 6.0 * floor(q / 6.0);\n  } else if (maxc == rgb.y) {\n    h = (rgb.z - rgb.x) / d + 2.0;\n  } else {\n    h = (rgb.x - rgb.y) / d + 4.0;\n  }\n  h = h * 60.0;\n  if (h < 0.0) { h = h + 360.0; }\n  return vec3f(h, s, v);\n}\n\nfn _gpu_color_mix(lch1: vec3f, lch2: vec3f, t: f32) -> vec3f {\n  let L = mix(lch1.x, lch2.x, t);\n  let C = mix(lch1.y, lch2.y, t);\n  let a1 = lch1.y < 1e-6;\n  let a2 = lch2.y < 1e-6;\n  var H: f32;\n  if (a1 && a2) {\n    H = lch1.z;\n  } else if (a1) {\n    H = lch2.z;\n  } else if (a2) {\n    H = lch1.z;\n  } else {\n    var dh = lch2.z - lch1.z;\n    if (dh > 180.0) { dh = dh - 360.0; }\n    if (dh < -180.0) { dh = dh + 360.0; }\n    H = lch1.z + dh * t;\n    if (H < 0.0) { H = H + 360.0; }\n    if (H >= 360.0) { H = H - 360.0; }\n  }\n  return vec3f(L, C, H);\n}\n\nfn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {\n  let bg = _gpu_oklch_to_srgb(lch_bg);\n  let fg = _gpu_oklch_to_srgb(lch_fg);\n  let bgR = _gpu_srgb_to_linear(bg.x);\n  let bgG = _gpu_srgb_to_linear(bg.y);\n  let bgB = _gpu_srgb_to_linear(bg.z);\n  let fgR = _gpu_srgb_to_linear(fg.x);\n  let fgG = _gpu_srgb_to_linear(fg.y);\n  let fgB = _gpu_srgb_to_linear(fg.z);\n  let bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  let fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  let bgC = pow(bgY, 0.56);\n  let fgC = pow(fgY, 0.57);\n  let contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
 /**
  * Abstract base class for GPU shader compilation targets.
  *

package/dist/types/compute-engine/compilation/interval-javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import { chop, factorial, factorial2, gcd, lcm, limit } from '../numerics/numeric';
 import { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi, fresnelS, fresnelC, sinc } from '../numerics/special-functions';
 import { choose } from '../boxed-expression/expand';
@@ -16,8 +16,19 @@ export declare class ComputeEngineFunction extends Function {
         contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
         colorToColorspace(input: string | number[], space: string): number[];
         colormap(name: string, arg?: number): number[] | number[][];
-        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        _interpolatePalette(colors: number[][], t: number): number[];
         colorFromColorspace(components: number[], space: string): number[];
+        rgb(r: number, g: number, b: number, alpha?: number): number[];
+        hsv(h: number, s: number, v: number, alpha?: number): number[];
+        hsl(h: number, s: number, l: number, alpha?: number): number[];
+        oklab(L: number, a: number, b: number, alpha?: number): number[];
+        oklch(L: number, C: number, H: number, alpha?: number): number[];
+        asRgb(input: string | number[]): number[];
+        asHsv(input: string | number[]): number[];
+        asHsl(input: string | number[]): number[];
+        asOklab(input: string | number[]): number[];
+        colorDelta(a: string | number[], b: string | number[]): number;
+        distance(a: number[], b: number[]): number;
         chop: typeof chop;
         factorial: typeof factorial;
         factorial2: typeof factorial2;
@@ -195,8 +206,19 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
         colorToColorspace(input: string | number[], space: string): number[];
         colormap(name: string, arg?: number): number[] | number[][];
-        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        _interpolatePalette(colors: number[][], t: number): number[];
         colorFromColorspace(components: number[], space: string): number[];
+        rgb(r: number, g: number, b: number, alpha?: number): number[];
+        hsv(h: number, s: number, v: number, alpha?: number): number[];
+        hsl(h: number, s: number, l: number, alpha?: number): number[];
+        oklab(L: number, a: number, b: number, alpha?: number): number[];
+        oklch(L: number, C: number, H: number, alpha?: number): number[];
+        asRgb(input: string | number[]): number[];
+        asHsv(input: string | number[]): number[];
+        asHsl(input: string | number[]): number[];
+        asOklab(input: string | number[]): number[];
+        colorDelta(a: string | number[], b: string | number[]): number;
+        distance(a: number[], b: number[]): number;
         chop: typeof chop;
         factorial: typeof factorial;
         factorial2: typeof factorial2;

package/dist/types/compute-engine/compilation/python-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * Python/NumPy language target implementation

package/dist/types/compute-engine/compilation/types.d.ts

@@ -1,15 +1,4 @@
-/* 0.55.5 */
-/**
- * A coordinate value with extended precision.
- *
- * - `number` — standard float64 (~16 decimal digits)
- * - `string` — arbitrary precision (parsed by BigDecimal)
- * - `{ hi, lo }` — double-double pair (~30 digits), true value = hi + lo
- */
-export type HighPrecisionCoord = number | string | {
-    hi: number;
-    lo: number;
-};
+/* 0.56.0 */
 /**
  * Source code in the target language
  */
@@ -64,8 +53,6 @@ export interface CompileTarget<Expr = unknown> {
     block?: (statements: string[]) => string;
     /** Target language identifier (for debugging/logging) */
     language?: string;
-    /** Compilation hints (viewport, etc.) passed through from options. */
-    hints?: CompilationOptions['hints'];
 }
 /**
  * Base interface for language-specific compilation targets
@@ -160,30 +147,6 @@ export interface CompilationOptions<Expr = unknown> {
      * results (e.g., plotting).
      */
     realOnly?: boolean;
-    /**
-     * Compilation hints for precision-adaptive strategies.
-     *
-     * The compiler may use these hints to select different code generation
-     * strategies (e.g., emulated double precision for deep-zoom fractals).
-     * Non-fractal functions ignore hints.
-     */
-    hints?: {
-        /** Current viewport for precision-adaptive compilation. */
-        viewport?: {
-            /**
-             * Center of the viewport as [re, im].
-             *
-             * Each coordinate can be:
-             * - `number` — standard float64 precision (~16 digits)
-             * - `string` — arbitrary precision (parsed by BigDecimal)
-             * - `{ hi, lo }` — double-double pair (~30 digits),
-             *    true value = hi + lo
-             */
-            center: [HighPrecisionCoord, HighPrecisionCoord];
-            /** Viewport radius (half-width in complex plane units). */
-            radius: number;
-        };
-    };
 }
 /**
  * Built-in targets that produce an executable `run` function.
@@ -284,35 +247,6 @@ export type CompilationResult<T extends string = string, R = number | ComplexRes
     calling?: 'expression' | 'lambda';
     /** Executable function (present for JS-executable targets only). */
     run?: CompiledRunner<R>;
-    /**
-     * Cheap staleness check for precision-adaptive compilation.
-     *
-     * The plot engine checks these thresholds on each viewport change
-     * (a few number comparisons). When any condition is met, the expression
-     * should be recompiled with updated hints.
-     */
-    staleWhen?: {
-        /** Recompile when viewport radius drops below this value. */
-        radiusBelow?: number;
-        /** Recompile when viewport radius rises above this value. */
-        radiusAbove?: number;
-        /** Recompile when center moves more than this distance. */
-        centerDistance?: number;
-    };
-    /** Scalar uniform values the shader needs. */
-    uniforms?: Record<string, number>;
-    /**
-     * Texture data the shader needs (e.g., reference orbit).
-     *
-     * Separated from `uniforms` because the GPU upload path is fundamentally
-     * different (createTexture + sampler vs uniform1f).
-     */
-    textures?: Record<string, {
-        data: Float32Array;
-        width: number;
-        height: number;
-        format: 'r32f' | 'rg32f' | 'rgba32f';
-    }>;
 } & (T extends ExecutableTarget ? {
     calling: 'expression' | 'lambda';
     run: CompiledRunner<R>;

package/dist/types/compute-engine/compilation/wgsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

package/dist/types/compute-engine/engine-assumptions.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { MathJsonSymbol } from '../math-json/types';
 export declare function ask(ce: IComputeEngine, pattern: Expression): BoxedSubstitution[];
 export declare function verify(ce: IComputeEngine, query: Expression): boolean | undefined;

package/dist/types/compute-engine/engine-cache.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
     private _entries;
     getOrBuild<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     invalidate(cacheName: string): void;

package/dist/types/compute-engine/engine-common-symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

package/dist/types/compute-engine/engine-compilation-targets.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { LanguageTarget } from './compilation/types';
 /**
  * Internal registry for compilation targets.

package/dist/types/compute-engine/engine-configuration-lifecycle.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

package/dist/types/compute-engine/engine-declarations.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { MathJsonSymbol } from '../math-json/types';
 import type { ValueDefinition, OperatorDefinition, AssignValue, Expression, BoxedDefinition, SymbolDefinition, IComputeEngine, Scope } from './global-types';

package/dist/types/compute-engine/engine-expression-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import { BigDecimal } from '../big-decimal';
 import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
 import { NumericValue } from './numeric-value/types';

package/dist/types/compute-engine/engine-extension-contracts.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { LanguageTarget, CompilationOptions } from './compilation/types';
 export declare function assertCompilationTargetName(name: unknown): string;
 export declare function assertLibraryName(name: unknown): string;

package/dist/types/compute-engine/engine-library-bootstrap.d.ts

@@ -1,3 +1,3 @@
-/* 0.55.5 */
+/* 0.56.0 */
 export declare function resolveBootstrapLibraries(libraries?: readonly (string | LibraryDefinition)[]): LibraryDefinition[];
 export declare function loadLibraryDefinitions(engine: ComputeEngine, libraries: readonly LibraryDefinition[]): void;

package/dist/types/compute-engine/engine-numeric-configuration.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _precision;

package/dist/types/compute-engine/engine-runtime-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

package/dist/types/compute-engine/engine-scope.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 export declare function pushScope(ce: IComputeEngine, scope?: Scope, name?: string): void;
 export declare function popScope(ce: IComputeEngine): void;
 export declare function pushEvalContext(ce: IComputeEngine, scope: Scope, name?: string): void;

package/dist/types/compute-engine/engine-sequences.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 export declare function declareSequence(ce: IComputeEngine, name: string, def: SequenceDefinition): IComputeEngine;
 export declare function getSequenceStatus(ce: IComputeEngine, name: string): SequenceStatus;
 export declare function getSequence(ce: IComputeEngine, name: string): SequenceInfo | undefined;

package/dist/types/compute-engine/engine-simplification-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 /**
  * Internal holder for simplification rules and their cache-staleness marker.
  *

package/dist/types/compute-engine/engine-startup-coordinator.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
 export type CommonNumberBindings = {
     Zero: Expression;

package/dist/types/compute-engine/engine-type-resolver.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 type ResolverScope = {
     parent: ResolverScope | null;
     types?: Record<string, TypeReference>;

package/dist/types/compute-engine/engine-validation-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { Expression, Metadata, ExpressionInput } from './global-types';
 type ValidationHost = {

package/dist/types/compute-engine/free-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';

package/dist/types/compute-engine/function-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

package/dist/types/compute-engine/global-types.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 export type * from './types-serialization';
 export type { ValueDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, OperatorDefinition, BaseDefinition, SimplifyOptions, SymbolDefinition, SymbolDefinitions, LibraryDefinition, AngularUnit, Sign, BaseCollectionHandlers, IndexedCollectionHandlers, CollectionHandlers, TaggedValueDefinition, TaggedOperatorDefinition, BoxedDefinition, BoxedBaseDefinition, BoxedValueDefinition, OperatorDefinitionFlags, BoxedOperatorDefinition, } from './types-definitions';
 export type * from './types-evaluation';

package/dist/types/compute-engine/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
 import { BigDecimal } from '../big-decimal';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -6,7 +6,7 @@ import type { OneOf } from '../common/one-of';
 import type { ConfigurationChangeListener } from '../common/configuration-change';
 import type { MathJsonExpression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
 import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, Scope, EvalContext, ExpressionInput, IComputeEngine, ILatexSyntax, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition } from './global-types';
-import type { LibraryCategory, ParseLatexOptions } from './latex-syntax/types';
+import type { LibraryCategory, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/types';
 import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
 import type { FormOption } from './types-serialization';
@@ -18,7 +18,7 @@ export type * from './global-types';
 export { parse, expr, simplify, evaluate, N, declare, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
 export { validatePattern };
 export { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
-export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, HighPrecisionCoord, } from './compilation/types';
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';
 export { BigDecimal } from '../big-decimal';
 export { JavaScriptTarget } from './compilation/javascript-target';
 export { GLSLTarget } from './compilation/glsl-target';
@@ -174,6 +174,7 @@ export declare class ComputeEngine implements IComputeEngine {
         precision?: number | 'machine';
         tolerance?: number | 'auto';
         latexSyntax?: ILatexSyntax;
+        latexOptions?: Partial<ParseLatexOptions & SerializeLatexOptions>;
     });
     toJSON(): string;
     [Symbol.toStringTag]: string;
@@ -650,6 +651,25 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal Returns the LatexSyntax instance, lazily creating one
      *  if a factory is registered. Throws if no LatexSyntax is available. */
     _requireLatexSyntax(): ILatexSyntax;
+    /** @internal Engine-wide LaTeX parse/serialize options (e.g. decimalSeparator).
+     *  Merged into every `parse()` and `toLatex()` call between the LatexSyntax
+     *  instance defaults and any per-call overrides. */
+    private _latexOptions;
+    /** Engine-wide LaTeX parse/serialize options.
+     *
+     * These options are merged into every `parse()` and `toLatex()` call.
+     * Precedence (most-specific wins):
+     *   1. LatexSyntax instance defaults (set at its construction)
+     *   2. `ce.latexOptions` (this property)
+     *   3. Per-call options passed to `ce.parse()` / `expr.toLatex()`
+     *
+     * Assigning replaces the whole bag. Use spread to merge:
+     * ```ts
+     * ce.latexOptions = { ...ce.latexOptions, decimalSeparator: '{,}' };
+     * ```
+     */
+    get latexOptions(): Partial<ParseLatexOptions & SerializeLatexOptions>;
+    set latexOptions(options: Partial<ParseLatexOptions & SerializeLatexOptions>);
     /**
      * Parse a LaTeX string and return a boxed expression.
      *

package/dist/types/compute-engine/interval/arithmetic.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

package/dist/types/compute-engine/interval/comparison.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

package/dist/types/compute-engine/interval/elementary.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
  *
  * @module interval/elementary

package/dist/types/compute-engine/interval/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * Interval arithmetic library for reliable function evaluation
  *
  * This module provides interval versions of mathematical operations

package/dist/types/compute-engine/interval/trigonometric.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

package/dist/types/compute-engine/interval/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * Interval arithmetic types for reliable function evaluation
  *
  * @module interval/types

package/dist/types/compute-engine/interval/util.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.5 */
+/* 0.56.0 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util