@cortex-js/compute-engine 0.55.4 → 0.55.5

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -130,8 +130,15 @@ export declare const GPU_DS_ARITHMETIC_PREAMBLE_WGSL = "\nfn ds_split(a: f32) ->
  * 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 = "\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";
+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).
  *
@@ -139,7 +146,7 @@ export declare const GPU_FRACTAL_DP_PREAMBLE_GLSL = "\nfloat _fractal_mandelbrot
  * 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 = "\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";
+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,13 +166,13 @@ export declare const GPU_FRACTAL_PREAMBLE_WGSL = "\nfn _fractal_mandelbrot(c: ve
  * 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;\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";
+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;\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";
+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).
  *

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * 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.4 */
+/* 0.55.5 */
 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';

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 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,4 +1,15 @@
-/* 0.55.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;
+};
 /**
  * Source code in the target language
  */
@@ -159,8 +170,16 @@ export interface CompilationOptions<Expr = unknown> {
     hints?: {
         /** Current viewport for precision-adaptive compilation. */
         viewport?: {
-            /** Center of the viewport as [re, im]. */
-            center: [number, number];
+            /**
+             * 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;
         };

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 /**
  * 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
     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.4 */
+/* 0.55.5 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 /**
  * 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 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.4 */
+/* 0.55.5 */
 import { BigDecimal } from '../big-decimal';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -18,7 +18,8 @@ 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, } from './compilation/types';
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, HighPrecisionCoord, } from './compilation/types';
+export { BigDecimal } from '../big-decimal';
 export { JavaScriptTarget } from './compilation/javascript-target';
 export { GLSLTarget } from './compilation/glsl-target';
 export { PythonTarget } from './compilation/python-target';

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * 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.4 */
+/* 0.55.5 */
  * 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.4 */
+/* 0.55.5 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * 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.4 */
+/* 0.55.5 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util

package/dist/types/compute-engine/latex-syntax/dictionary/default-dictionary.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * Default LaTeX dictionary assembly.
  *
  * This file imports all individual domain dictionaries and assembles them

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import type { MathJsonExpression } from '../../../math-json';
 export declare const DEFINITIONS_LOGIC: LatexDictionary;
 export declare function parseQuantifier(kind: 'NotForAll' | 'NotExists' | 'ForAll' | 'Exists' | 'ExistsUnique'): (parser: Parser, terminator: Readonly<Terminator>) => MathJsonExpression | null;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-relational-operators.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -1,3 +1,3 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-units.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * LaTeX dictionary entries for parsing and serializing physical quantities
  * with units.
  *

package/dist/types/compute-engine/latex-syntax/dictionary/definitions.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import { LatexDictionaryEntry } from '../types';
 export type { CommonEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPrefixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary, } from './indexed-types';
 import type { IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary } from './indexed-types';

package/dist/types/compute-engine/latex-syntax/dictionary/indexed-types.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * Type definitions for the indexed LaTeX dictionary.
  *
  * These are separated from definitions.ts to break a circular dependency:

package/dist/types/compute-engine/latex-syntax/latex-syntax.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * Standalone LaTeX <-> MathJSON parsing and serialization.
  *
  * This module provides a `LatexSyntax` class and free-standing `parse()` /

package/dist/types/compute-engine/latex-syntax/parse-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * Number parsing extracted from the _Parser class for modularity.
  *
  * All functions take a `Parser` interface and a `NumberFormatTokens` config

package/dist/types/compute-engine/latex-syntax/parse-symbol.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import { Parser } from './types';
 /** For error handling, if we have a symbol prefix, assume
  * the symbol is invalid (it would have been captured by

package/dist/types/compute-engine/latex-syntax/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { BoxedType } from '../../common/type/boxed-type';

package/dist/types/compute-engine/latex-syntax/serialize-dms.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * DMS (Degrees-Minutes-Seconds) serialization utilities.
  */
 export interface DMSComponents {

package/dist/types/compute-engine/latex-syntax/serialize-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import { NumberSerializationFormat } from './types';
 /**
  * @param expr - A number, can be represented as a string

package/dist/types/compute-engine/latex-syntax/serializer-style.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import { DelimiterScale } from './types';
 export declare function getApplyFunctionStyle(_expr: MathJsonExpression, _level: number): DelimiterScale;
 export declare function getGroupStyle(_expr: MathJsonExpression, _level: number): DelimiterScale;

package/dist/types/compute-engine/latex-syntax/serializer.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {

package/dist/types/compute-engine/latex-syntax/tokenizer.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

package/dist/types/compute-engine/latex-syntax/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 import type { MathJsonExpression, MathJsonSymbol } from '../../math-json/types';
 import type { TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';

package/dist/types/compute-engine/latex-syntax/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare function asLatexString(s: unknown): string | null;
 export declare function isRelationalOperator(name: string | undefined): boolean;
 export declare function isInequalityOperator(operator: string | undefined): boolean;

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

@@ -1,3 +1,3 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
 /**

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

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const COLORS_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const COMPLEX_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const CONTROL_STRUCTURES_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.55.4 */
+/* 0.55.5 */
 export declare const CORE_LIBRARY: SymbolDefinitions[];