@cortex-js/compute-engine 0.55.3 → 0.55.5

package/dist/compile.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.3 */
+/** Compute Engine 0.55.5 */
 
 // src/compute-engine/numerics/richardson.ts
 function extrapolate(f, x0, options = {}) {
@@ -15066,7 +15066,8 @@ function compile(expr, options) {
       vars: options?.vars,
       imports: options?.imports,
       preamble: options?.preamble,
-      realOnly: options?.realOnly
+      realOnly: options?.realOnly,
+      hints: options?.hints
     });
   } catch (e) {
     if (options?.fallback ?? true) {
@@ -16472,30 +16473,6 @@ var COOLWARM = [
   "#ae2036",
   "#b40426"
 ];
-var OCEAN_BALANCE = [
-  "#00441b",
-  "#006d5b",
-  "#1a8c7d",
-  "#2fa394",
-  "#4fb3a3",
-  "#6fc1b3",
-  "#8dcfc3",
-  "#a6dbd1",
-  "#bfe6de",
-  "#d7f0ea",
-  "#f7f7f7",
-  "#eeeeee",
-  "#ddd8e6",
-  "#c7bcda",
-  "#b3a0d0",
-  "#9f86c7",
-  "#8d6dbd",
-  "#7b56b1",
-  "#6a42a3",
-  "#5a3093",
-  "#4a1f82",
-  "#3b0f70"
-];
 var reversePalette = (palette) => palette.slice().reverse();
 var DIVERGING_PALETTES = {
   roma: ROMA,
@@ -16507,9 +16484,7 @@ var DIVERGING_PALETTES = {
   rdbu: RDBU,
   "rdbu-reversed": reversePalette(RDBU),
   coolwarm: COOLWARM,
-  "coolwarm-reversed": reversePalette(COOLWARM),
-  "ocean-balance": OCEAN_BALANCE,
-  "ocean-balance-reversed": reversePalette(OCEAN_BALANCE)
+  "coolwarm-reversed": reversePalette(COOLWARM)
 };
 var TURBO = [
   "#30123b",
@@ -18593,6 +18568,40 @@ var GREY = [
   "#eeeeee",
   "#ffffff"
 ];
+var CMOCEAN_PHASE = [
+  "#a8780d",
+  "#b3701b",
+  "#be6828",
+  "#c75f35",
+  "#cf5643",
+  "#d54b53",
+  "#db4066",
+  "#de357b",
+  "#df2a93",
+  "#dc25ad",
+  "#d529c4",
+  "#cc34d7",
+  "#c041e5",
+  "#b24fef",
+  "#a25cf3",
+  "#9168f4",
+  "#7d73f0",
+  "#687ce8",
+  "#5285dc",
+  "#3d8bcd",
+  "#2c90bc",
+  "#2093ac",
+  "#19959c",
+  "#12978c",
+  "#0c987c",
+  "#119a69",
+  "#249a52",
+  "#409839",
+  "#5e9420",
+  "#778d12",
+  "#8b860d",
+  "#9b7f0d"
+];
 var reversePalette2 = (palette) => palette.slice().reverse();
 var SEQUENTIAL_PALETTES = {
   turbo: TURBO,
@@ -18616,7 +18625,9 @@ var SEQUENTIAL_PALETTES = {
   "rocket-reversed": reversePalette2(ROCKET),
   mako: MAKO,
   // blue to teal
-  "mako-reversed": reversePalette2(MAKO)
+  "mako-reversed": reversePalette2(MAKO),
+  "cmocean-phase": CMOCEAN_PHASE,
+  "cmocean-phase-reversed": reversePalette2(CMOCEAN_PHASE)
 };
 
 // src/compute-engine/numerics/special-functions.ts
@@ -20738,6 +20749,43 @@ function fibonacci(n) {
   return b;
 }
 
+// src/compute-engine/compilation/fractal-orbit.ts
+function toBigDecimal(v) {
+  if (typeof v === "object" && "hi" in v)
+    return new BigDecimal(v.hi).add(new BigDecimal(v.lo));
+  return new BigDecimal(v);
+}
+function hpToNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") return Number(v);
+  return v.hi + v.lo;
+}
+function computeReferenceOrbit(center, maxIter, precision) {
+  const prevPrecision = BigDecimal.precision;
+  BigDecimal.precision = precision;
+  try {
+    const cr = toBigDecimal(center[0]);
+    const ci = toBigDecimal(center[1]);
+    let zr = BigDecimal.ZERO;
+    let zi = BigDecimal.ZERO;
+    const ESCAPE = new BigDecimal(256);
+    const points = [];
+    for (let i = 0; i < maxIter; i++) {
+      points.push(zr.toNumber(), zi.toNumber());
+      const zr2 = zr.mul(zr).toPrecision(precision);
+      const zi2 = zi.mul(zi).toPrecision(precision);
+      const mag2 = zr2.add(zi2);
+      if (mag2.cmp(ESCAPE) > 0) break;
+      const new_zi = zr.mul(zi).toPrecision(precision).mul(2).add(ci);
+      zr = zr2.sub(zi2).add(cr);
+      zi = new_zi;
+    }
+    return new Float32Array(points);
+  } finally {
+    BigDecimal.precision = prevPrecision;
+  }
+}
+
 // src/compute-engine/compilation/gpu-target.ts
 var GPU_OPERATORS = {
   Add: ["+", 11],
@@ -20821,6 +20869,13 @@ function compileGPUSumProduct(kind, args, _compile, target) {
   ];
   return lines.join("\n");
 }
+function selectFractalStrategy(target) {
+  const radius = target.hints?.viewport?.radius;
+  if (radius === void 0) return "single";
+  if (radius > 1e-6) return "single";
+  if (radius > 1e-14) return "double";
+  return "perturbation";
+}
 var GPU_FUNCTIONS = {
   // Variadic arithmetic (for function-call form, e.g., with vectors)
   Add: (args, compile2, target) => {
@@ -21316,12 +21371,32 @@ var GPU_FUNCTIONS = {
     if (c === null || maxIter === null)
       throw new Error("Mandelbrot: missing arguments");
     const iterCode = compileIntArg(maxIter, compile2, target);
+    const strategy = selectFractalStrategy(target);
+    if (strategy === "double") {
+      const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
+      return `_fractal_mandelbrot_dp(${dpCoord}, ${iterCode})`;
+    }
+    if (strategy === "perturbation") {
+      const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
+      return `_fractal_mandelbrot_pt(${ptDelta}, ${iterCode})`;
+    }
     return `_fractal_mandelbrot(${compile2(c)}, ${iterCode})`;
   },
   Julia: ([z, c, maxIter], compile2, target) => {
     if (z === null || c === null || maxIter === null)
       throw new Error("Julia: missing arguments");
     const iterCode = compileIntArg(maxIter, compile2, target);
+    const strategy = selectFractalStrategy(target);
+    if (strategy === "double") {
+      const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
+      const cCode = compile2(c);
+      return `_fractal_julia_dp(${dpCoord}, vec4(${cCode}, vec2(0.0)), ${iterCode})`;
+    }
+    if (strategy === "perturbation") {
+      const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
+      const cCode = compile2(c);
+      return `_fractal_julia_pt(${ptDelta}, ${cCode}, ${iterCode})`;
+    }
     return `_fractal_julia(${compile2(z)}, ${compile2(c)}, ${iterCode})`;
   },
   // Vector/Matrix operations
@@ -21919,6 +21994,232 @@ fn _gpu_besselJ(n_in: i32, x_in: f32) -> f32 {
   return sgn * vals[n] / norm;
 }
 `;
+var GPU_DS_ARITHMETIC_PREAMBLE_GLSL = `
+// Split a float into high and low parts for exact multiplication
+vec2 ds_split(float a) {
+  const float SPLIT = 4097.0; // 2^12 + 1
+  float t = SPLIT * a;
+  float hi = t - (t - a);
+  float lo = a - hi;
+  return vec2(hi, lo);
+}
+
+// Create a double-single from a single float
+vec2 ds_from(float a) {
+  return vec2(a, 0.0);
+}
+
+// Error-free addition (Knuth TwoSum)
+vec2 ds_add(vec2 a, vec2 b) {
+  float s = a.x + b.x;
+  float v = s - a.x;
+  float e = (a.x - (s - v)) + (b.x - v);
+  float lo = (a.y + b.y) + e;
+  float hi = s + lo;
+  lo = lo - (hi - s);
+  return vec2(hi, lo);
+}
+
+// Double-single subtraction
+vec2 ds_sub(vec2 a, vec2 b) {
+  return ds_add(a, vec2(-b.x, -b.y));
+}
+
+// Error-free multiplication (Dekker TwoProduct)
+vec2 ds_mul(vec2 a, vec2 b) {
+  float p = a.x * b.x;
+  vec2 sa = ds_split(a.x);
+  vec2 sb = ds_split(b.x);
+  float err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;
+  err += a.x * b.y + a.y * b.x;
+  float hi = p + err;
+  float lo = err - (hi - p);
+  return vec2(hi, lo);
+}
+
+// Optimized self-multiply
+vec2 ds_sqr(vec2 a) {
+  float p = a.x * a.x;
+  vec2 sa = ds_split(a.x);
+  float err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;
+  err += 2.0 * a.x * a.y;
+  float hi = p + err;
+  float lo = err - (hi - p);
+  return vec2(hi, lo);
+}
+
+// Compare magnitude: returns -1, 0, or 1
+float ds_cmp(vec2 a, vec2 b) {
+  float d = a.x - b.x;
+  if (d != 0.0) return sign(d);
+  return sign(a.y - b.y);
+}
+`;
+var GPU_DS_ARITHMETIC_PREAMBLE_WGSL = `
+fn ds_split(a: f32) -> vec2f {
+  const SPLIT: f32 = 4097.0;
+  let t = SPLIT * a;
+  let hi = t - (t - a);
+  let lo = a - hi;
+  return vec2f(hi, lo);
+}
+
+fn ds_from(a: f32) -> vec2f {
+  return vec2f(a, 0.0);
+}
+
+fn ds_add(a: vec2f, b: vec2f) -> vec2f {
+  let s = a.x + b.x;
+  let v = s - a.x;
+  let e = (a.x - (s - v)) + (b.x - v);
+  let lo_t = (a.y + b.y) + e;
+  let hi = s + lo_t;
+  let lo = lo_t - (hi - s);
+  return vec2f(hi, lo);
+}
+
+fn ds_sub(a: vec2f, b: vec2f) -> vec2f {
+  return ds_add(a, vec2f(-b.x, -b.y));
+}
+
+fn ds_mul(a: vec2f, b: vec2f) -> vec2f {
+  let p = a.x * b.x;
+  let sa = ds_split(a.x);
+  let sb = ds_split(b.x);
+  var err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;
+  err += a.x * b.y + a.y * b.x;
+  let hi = p + err;
+  let lo = err - (hi - p);
+  return vec2f(hi, lo);
+}
+
+fn ds_sqr(a: vec2f) -> vec2f {
+  let p = a.x * a.x;
+  let sa = ds_split(a.x);
+  var err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;
+  err += 2.0 * a.x * a.y;
+  let hi = p + err;
+  let lo = err - (hi - p);
+  return vec2f(hi, lo);
+}
+
+fn ds_cmp(a: vec2f, b: vec2f) -> f32 {
+  let d = a.x - b.x;
+  if (d != 0.0) { return sign(d); }
+  return sign(a.y - b.y);
+}
+`;
+var GPU_FRACTAL_DP_PREAMBLE_GLSL = `
+uniform float _dp_cx_hi;
+uniform float _dp_cx_lo;
+uniform float _dp_cy_hi;
+uniform float _dp_cy_lo;
+uniform float _dp_w;
+uniform float _dp_h;
+
+vec4 _dp_coord() {
+  // Per-pixel offset from center \u2014 small, so float-precise
+  float dx = (v_uv.x - 0.5) * _dp_w;
+  float dy = (v_uv.y - 0.5) * _dp_h;
+  // Combine center (hi+lo) + delta with emulated double precision
+  vec2 cre = ds_add(vec2(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
+  vec2 cim = ds_add(vec2(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
+  return vec4(cre.x, cim.x, cre.y, cim.y);
+}
+
+float _fractal_mandelbrot_dp(vec4 c, int maxIter) {
+  // c = (re_hi, im_hi, re_lo, im_lo)
+  vec2 cr = vec2(c.x, c.z);  // real part as ds
+  vec2 ci = vec2(c.y, c.w);  // imag part as ds
+  vec2 zr = vec2(0.0, 0.0);
+  vec2 zi = vec2(0.0, 0.0);
+  for (int i = 0; i < maxIter; i++) {
+    vec2 zr2 = ds_sqr(zr);
+    vec2 zi2 = ds_sqr(zi);
+    // |z|^2 > 4.0 ?
+    vec2 mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0)
+      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);
+    // z = z^2 + c
+    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci); // 2*zr*zi + ci
+    zr = ds_add(ds_sub(zr2, zi2), cr);                    // zr^2 - zi^2 + cr
+    zi = new_zi;
+  }
+  return 1.0;
+}
+
+float _fractal_julia_dp(vec4 z_in, vec4 c, int maxIter) {
+  vec2 zr = vec2(z_in.x, z_in.z);
+  vec2 zi = vec2(z_in.y, z_in.w);
+  vec2 cr = vec2(c.x, c.z);
+  vec2 ci = vec2(c.y, c.w);
+  for (int i = 0; i < maxIter; i++) {
+    vec2 zr2 = ds_sqr(zr);
+    vec2 zi2 = ds_sqr(zi);
+    vec2 mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0)
+      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);
+    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
+    zr = ds_add(ds_sub(zr2, zi2), cr);
+    zi = new_zi;
+  }
+  return 1.0;
+}
+`;
+var GPU_FRACTAL_DP_PREAMBLE_WGSL = `
+@group(0) @binding(10) var<uniform> _dp_cx_hi: f32;
+@group(0) @binding(11) var<uniform> _dp_cx_lo: f32;
+@group(0) @binding(12) var<uniform> _dp_cy_hi: f32;
+@group(0) @binding(13) var<uniform> _dp_cy_lo: f32;
+@group(0) @binding(14) var<uniform> _dp_w: f32;
+@group(0) @binding(15) var<uniform> _dp_h: f32;
+
+fn _dp_coord(uv: vec2f) -> vec4f {
+  let dx = (uv.x - 0.5) * _dp_w;
+  let dy = (uv.y - 0.5) * _dp_h;
+  let cre = ds_add(vec2f(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
+  let cim = ds_add(vec2f(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
+  return vec4f(cre.x, cim.x, cre.y, cim.y);
+}
+
+fn _fractal_mandelbrot_dp(c: vec4f, maxIter: i32) -> f32 {
+  let cr = vec2f(c.x, c.z);
+  let ci = vec2f(c.y, c.w);
+  var zr = vec2f(0.0, 0.0);
+  var zi = vec2f(0.0, 0.0);
+  for (var i: i32 = 0; i < maxIter; i++) {
+    let zr2 = ds_sqr(zr);
+    let zi2 = ds_sqr(zi);
+    let mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
+    zr = ds_add(ds_sub(zr2, zi2), cr);
+    zi = new_zi;
+  }
+  return 1.0;
+}
+
+fn _fractal_julia_dp(z_in: vec4f, c: vec4f, maxIter: i32) -> f32 {
+  var zr = vec2f(z_in.x, z_in.z);
+  var zi = vec2f(z_in.y, z_in.w);
+  let cr = vec2f(c.x, c.z);
+  let ci = vec2f(c.y, c.w);
+  for (var i: i32 = 0; i < maxIter; i++) {
+    let zr2 = ds_sqr(zr);
+    let zi2 = ds_sqr(zi);
+    let mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
+    zr = ds_add(ds_sub(zr2, zi2), cr);
+    zi = new_zi;
+  }
+  return 1.0;
+}
+`;
 var GPU_FRACTAL_PREAMBLE_GLSL = `
 float _fractal_mandelbrot(vec2 c, int maxIter) {
   vec2 z = vec2(0.0, 0.0);
@@ -21962,6 +22263,208 @@ fn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {
   return 1.0;
 }
 `;
+var GPU_FRACTAL_PT_PREAMBLE_GLSL = `
+uniform sampler2D _refOrbit;
+uniform int _refOrbitLen;
+uniform int _refOrbitTexWidth;
+uniform float _pt_offset_x;
+uniform float _pt_offset_y;
+uniform float _pt_w;
+uniform float _pt_h;
+
+vec2 _pt_delta() {
+  float dx = _pt_offset_x + (v_uv.x - 0.5) * _pt_w;
+  float dy = _pt_offset_y + (v_uv.y - 0.5) * _pt_h;
+  return vec2(dx, dy);
+}
+
+vec2 _pt_fetch_orbit(int i) {
+  int y = i / _refOrbitTexWidth;
+  int x = i - y * _refOrbitTexWidth;
+  return texelFetch(_refOrbit, ivec2(x, y), 0).rg;
+}
+
+float _fractal_mandelbrot_pt(vec2 delta_c, int maxIter) {
+  float dr = 0.0;
+  float di = 0.0;
+  int orbitLen = min(maxIter, _refOrbitLen);
+  for (int i = 0; i < orbitLen; i++) {
+    vec2 Zn = _pt_fetch_orbit(i);
+    // delta_{n+1} = 2*Z_n*delta_n + delta_n^2 + delta_c
+    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    // Full z = Z_{n+1} + delta for escape check
+    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);
+    float zr = Zn1.x + dr;
+    float zi = Zn1.y + di;
+    float mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0)
+      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+    // Glitch detection: |delta|^2 > |Z|^2
+    float dmag2 = dr * dr + di * di;
+    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      // Rebase to absolute coordinates and continue with single-float
+      float abs_zr = Zn1.x + dr;
+      float abs_zi = Zn1.y + di;
+      // Reconstruct absolute c from reference + delta
+      // (Use ds_from for the concept, but single-float suffices for fallback)
+      float cx = abs_zr - dr + delta_c.x;
+      float cy = abs_zi - di + delta_c.y;
+      for (int j = i + 1; j < maxIter; j++) {
+        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;
+        abs_zi = 2.0 * abs_zr * abs_zi + cy;
+        abs_zr = new_zr;
+        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;
+        if (mag2 > 4.0)
+          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+
+float _fractal_julia_pt(vec2 z_delta, vec2 delta_c, int maxIter) {
+  float dr = z_delta.x;
+  float di = z_delta.y;
+  int orbitLen = min(maxIter, _refOrbitLen);
+  for (int i = 0; i < orbitLen; i++) {
+    vec2 Zn = _pt_fetch_orbit(i);
+    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);
+    float zr = Zn1.x + dr;
+    float zi = Zn1.y + di;
+    float mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0)
+      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+    float dmag2 = dr * dr + di * di;
+    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      float abs_zr = Zn1.x + dr;
+      float abs_zi = Zn1.y + di;
+      float cx = delta_c.x;
+      float cy = delta_c.y;
+      for (int j = i + 1; j < maxIter; j++) {
+        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;
+        abs_zi = 2.0 * abs_zr * abs_zi + cy;
+        abs_zr = new_zr;
+        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;
+        if (mag2 > 4.0)
+          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+`;
+var GPU_FRACTAL_PT_PREAMBLE_WGSL = `
+@group(0) @binding(1) var _refOrbit: texture_2d<f32>;
+var<uniform> _refOrbitLen: i32;
+var<uniform> _refOrbitTexWidth: i32;
+var<uniform> _pt_offset_x: f32;
+var<uniform> _pt_offset_y: f32;
+var<uniform> _pt_w: f32;
+var<uniform> _pt_h: f32;
+
+fn _pt_delta(uv: vec2f) -> vec2f {
+  let dx = _pt_offset_x + (uv.x - 0.5) * _pt_w;
+  let dy = _pt_offset_y + (uv.y - 0.5) * _pt_h;
+  return vec2f(dx, dy);
+}
+
+fn _pt_fetch_orbit(i: i32) -> vec2f {
+  let y = i / _refOrbitTexWidth;
+  let x = i - y * _refOrbitTexWidth;
+  return textureLoad(_refOrbit, vec2i(x, y), 0).rg;
+}
+
+fn _fractal_mandelbrot_pt(delta_c: vec2f, maxIter: i32) -> f32 {
+  var dr: f32 = 0.0;
+  var di: f32 = 0.0;
+  let orbitLen = min(maxIter, _refOrbitLen);
+  for (var i: i32 = 0; i < orbitLen; i++) {
+    let Zn = _pt_fetch_orbit(i);
+    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    var Zn1 = vec2f(0.0);
+    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }
+    let zr = Zn1.x + dr;
+    let zi = Zn1.y + di;
+    var mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let dmag2 = dr * dr + di * di;
+    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      var f_zr = Zn1.x + dr;
+      var f_zi = Zn1.y + di;
+      let cx = delta_c.x;
+      let cy = delta_c.y;
+      for (var j: i32 = i + 1; j < maxIter; j++) {
+        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;
+        f_zi = 2.0 * f_zr * f_zi + cy;
+        f_zr = t_zr;
+        mag2 = f_zr * f_zr + f_zi * f_zi;
+        if (mag2 > 4.0) {
+          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+        }
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+
+fn _fractal_julia_pt(z_delta: vec2f, delta_c: vec2f, maxIter: i32) -> f32 {
+  var dr = z_delta.x;
+  var di = z_delta.y;
+  let orbitLen = min(maxIter, _refOrbitLen);
+  for (var i: i32 = 0; i < orbitLen; i++) {
+    let Zn = _pt_fetch_orbit(i);
+    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    var Zn1 = vec2f(0.0);
+    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }
+    let zr = Zn1.x + dr;
+    let zi = Zn1.y + di;
+    var mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let dmag2 = dr * dr + di * di;
+    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      var f_zr = Zn1.x + dr;
+      var f_zi = Zn1.y + di;
+      let cx = delta_c.x;
+      let cy = delta_c.y;
+      for (var j: i32 = i + 1; j < maxIter; j++) {
+        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;
+        f_zi = 2.0 * f_zr * f_zi + cy;
+        f_zr = t_zr;
+        mag2 = f_zr * f_zr + f_zi * f_zi;
+        if (mag2 > 4.0) {
+          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+        }
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+`;
 var GPU_COLOR_PREAMBLE_GLSL = `
 float _gpu_srgb_to_linear(float c) {
   if (c <= 0.04045) return c / 12.92;
@@ -22400,6 +22903,7 @@ var GPUShaderTarget = class {
     const constants = this.getConstants();
     const v2 = this.languageId === "wgsl" ? "vec2f" : "vec2";
     const target = this.createTarget({
+      hints: options.hints,
       functions: (id) => {
         if (userFunctions && id in userFunctions) {
           const fn = userFunctions[id];
@@ -22438,12 +22942,89 @@ var GPUShaderTarget = class {
     if (code.includes("_gpu_besselJ"))
       preamble += this.languageId === "wgsl" ? GPU_BESSELJ_PREAMBLE_WGSL : GPU_BESSELJ_PREAMBLE_GLSL;
     if (code.includes("_fractal_")) {
-      preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
+      if (code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) {
+        preamble += this.languageId === "wgsl" ? GPU_DS_ARITHMETIC_PREAMBLE_WGSL : GPU_DS_ARITHMETIC_PREAMBLE_GLSL;
+        preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PT_PREAMBLE_WGSL : GPU_FRACTAL_PT_PREAMBLE_GLSL;
+      } else if (code.includes("_fractal_mandelbrot_dp") || code.includes("_fractal_julia_dp")) {
+        preamble += this.languageId === "wgsl" ? GPU_DS_ARITHMETIC_PREAMBLE_WGSL : GPU_DS_ARITHMETIC_PREAMBLE_GLSL;
+        preamble += this.languageId === "wgsl" ? GPU_FRACTAL_DP_PREAMBLE_WGSL : GPU_FRACTAL_DP_PREAMBLE_GLSL;
+      } else {
+        preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
+      }
     }
     if (code.includes("_gpu_srgb_to") || code.includes("_gpu_oklab") || code.includes("_gpu_oklch") || code.includes("_gpu_color_mix") || code.includes("_gpu_apca")) {
       preamble += this.languageId === "wgsl" ? GPU_COLOR_PREAMBLE_WGSL : GPU_COLOR_PREAMBLE_GLSL;
     }
     if (preamble) result.preamble = preamble;
+    if (code.includes("_fractal_") && options.hints?.viewport) {
+      const strategy = selectFractalStrategy(target);
+      const radius = options.hints.viewport.radius;
+      switch (strategy) {
+        case "single":
+          result.staleWhen = { radiusBelow: 1e-6 };
+          break;
+        case "double":
+          result.staleWhen = { radiusBelow: 1e-14, radiusAbove: 1e-5 };
+          break;
+        case "perturbation":
+          result.staleWhen = {
+            radiusAbove: 1e-5,
+            radiusBelow: radius * 0.01,
+            centerDistance: radius * 2
+          };
+          break;
+      }
+    }
+    if ((code.includes("_fractal_mandelbrot_dp") || code.includes("_fractal_julia_dp")) && options.hints?.viewport) {
+      const cx = hpToNumber(options.hints.viewport.center[0]);
+      const cy = hpToNumber(options.hints.viewport.center[1]);
+      const size = options.hints.viewport.radius * 2;
+      const cx_hi = Math.fround(cx);
+      const cy_hi = Math.fround(cy);
+      result.uniforms = {
+        ...result.uniforms,
+        _dp_cx_hi: cx_hi,
+        _dp_cx_lo: cx - cx_hi,
+        _dp_cy_hi: cy_hi,
+        _dp_cy_lo: cy - cy_hi,
+        _dp_w: size,
+        _dp_h: size
+      };
+    }
+    if ((code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) && options.hints?.viewport) {
+      const viewport = options.hints.viewport;
+      const size = viewport.radius * 2;
+      result.uniforms = {
+        ...result.uniforms,
+        _pt_offset_x: 0,
+        _pt_offset_y: 0,
+        _pt_w: size,
+        _pt_h: size
+      };
+      const digits = Math.max(50, Math.ceil(-Math.log10(viewport.radius)) + 10);
+      const maxIter = 1e3;
+      const orbit = computeReferenceOrbit(
+        viewport.center,
+        maxIter,
+        digits
+      );
+      const orbitLen = orbit.length / 2;
+      const texWidth = Math.min(orbitLen, 4096);
+      const texHeight = Math.ceil(orbitLen / texWidth);
+      result.textures = {
+        _refOrbit: {
+          data: orbit,
+          width: texWidth,
+          height: texHeight,
+          format: "rg32f"
+        }
+      };
+      result.uniforms = {
+        ...result.uniforms,
+        _refOrbitLen: orbitLen,
+        _refOrbitTexWidth: texWidth
+      };
+    }
     return result;
   }
   compileToSource(expr, _options = {}) {
@@ -24778,7 +25359,7 @@ function compileToIntervalTarget(expr, target) {
 }
 
 // src/compile.ts
-var version = "0.55.3";
+var version = "0.55.5";
 export {
   BaseCompiler,
   GLSLTarget,