@cortex-js/compute-engine 0.57.0 → 0.59.0

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { Expression, JSSource } from '../global-types';
 import type { CompileTarget, CompilationResult } from './types';
 type CompileExpressionOptions<T extends string = string> = {

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Constant folding utilities for GPU compilation.
  *
  * These helpers allow compilation handlers to detect compile-time constants,
@@ -29,6 +29,21 @@ export declare function tryGetConstant(expr: Expression): number | undefined;
  * short-circuits on `0.0` (absorbing element), returns `"1.0"` for empty input.
  */
 export declare function foldTerms(terms: string[], identity: string, op: '+' | '*'): string;
+/**
+ * Parenthesize a compiled operand for safe use as a multiplicative factor.
+ *
+ * `foldTerms(..., '*')` joins operand strings with ` * ` without adding
+ * precedence parentheses. That is fine when operands come through the
+ * operator path (which already wraps lower-precedence operands), but the
+ * complex-multiply function handlers compile their operands with no
+ * precedence context, so a top-level additive factor like `x + 1.0` would be
+ * joined as `x + 1.0 * z` (mis-grouped). Wrap `Add`/`Subtract` operands so
+ * they bind as a single factor.
+ *
+ * @param expr The source expression for the operand.
+ * @param code The already-compiled operand code.
+ */
+export declare function parenthesizeFactor(expr: Expression, code: string): string;
 /**
  * Decompose an expression into real and imaginary compiled code strings
  * for direct `vec2(re, im)` construction.

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -33,14 +33,24 @@ export declare function compileGPUMatrix(args: ReadonlyArray<Expression>, compil
  * GPU gamma function using Lanczos approximation (g=7, n=9 coefficients).
  *
  * Uses reflection formula for z < 0.5 and Lanczos for z >= 0.5.
- * Valid for both GLSL and WGSL (uses standard math builtins).
+ * GLSL syntax.
  */
-export declare const GPU_GAMMA_PREAMBLE = "\nfloat _gpu_gamma(float z) {\n  const float PI = 3.14159265358979;\n  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)\n  float w = z;\n  if (z < 0.5) w = 1.0 - z;\n  w -= 1.0;\n  float x = 0.99999999999980993;\n  x += 676.5203681218851 / (w + 1.0);\n  x += -1259.1392167224028 / (w + 2.0);\n  x += 771.32342877765313 / (w + 3.0);\n  x += -176.61502916214059 / (w + 4.0);\n  x += 12.507343278686905 / (w + 5.0);\n  x += -0.13857109526572012 / (w + 6.0);\n  x += 9.9843695780195716e-6 / (w + 7.0);\n  x += 1.5056327351493116e-7 / (w + 8.0);\n  float t = w + 7.5;\n  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;\n  if (z < 0.5) return PI / (sin(PI * z) * g);\n  return g;\n}\n\nfloat _gpu_gammaln(float z) {\n  // Stirling asymptotic expansion for ln(Gamma(z)), z > 0\n  float z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
+export declare const GPU_GAMMA_PREAMBLE_GLSL = "\nfloat _gpu_gamma(float z) {\n  const float PI = 3.14159265358979;\n  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)\n  float w = z;\n  if (z < 0.5) w = 1.0 - z;\n  w -= 1.0;\n  float x = 0.99999999999980993;\n  x += 676.5203681218851 / (w + 1.0);\n  x += -1259.1392167224028 / (w + 2.0);\n  x += 771.32342877765313 / (w + 3.0);\n  x += -176.61502916214059 / (w + 4.0);\n  x += 12.507343278686905 / (w + 5.0);\n  x += -0.13857109526572012 / (w + 6.0);\n  x += 9.9843695780195716e-6 / (w + 7.0);\n  x += 1.5056327351493116e-7 / (w + 8.0);\n  float t = w + 7.5;\n  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;\n  if (z < 0.5) return PI / (sin(PI * z) * g);\n  return g;\n}\n\nfloat _gpu_gammaln(float z) {\n  // Stirling asymptotic expansion for ln(Gamma(z)), z > 0\n  float z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
+/**
+ * GPU Gamma function preamble (WGSL syntax). WGSL has no implicit GLSL-style
+ * `float`/braceless-`if` syntax, so a `_WGSL` variant is required (the GLSL
+ * preamble does not compile as WGSL).
+ */
+export declare const GPU_GAMMA_PREAMBLE_WGSL = "\nfn _gpu_gamma(z: f32) -> f32 {\n  let PI = 3.14159265358979;\n  var w = z;\n  if (z < 0.5) { w = 1.0 - z; }\n  w = w - 1.0;\n  var x = 0.99999999999980993;\n  x = x + 676.5203681218851 / (w + 1.0);\n  x = x + -1259.1392167224028 / (w + 2.0);\n  x = x + 771.32342877765313 / (w + 3.0);\n  x = x + -176.61502916214059 / (w + 4.0);\n  x = x + 12.507343278686905 / (w + 5.0);\n  x = x + -0.13857109526572012 / (w + 6.0);\n  x = x + 9.9843695780195716e-6 / (w + 7.0);\n  x = x + 1.5056327351493116e-7 / (w + 8.0);\n  let t = w + 7.5;\n  let g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;\n  if (z < 0.5) { return PI / (sin(PI * z) * g); }\n  return g;\n}\n\nfn _gpu_gammaln(z: f32) -> f32 {\n  let z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
 /**
  * GPU error function using Abramowitz & Stegun approximation.
- * Maximum error: |epsilon(x)| <= 1.5e-7.
+ * Maximum error: |epsilon(x)| <= 1.5e-7. GLSL syntax.
  */
-export declare const GPU_ERF_PREAMBLE = "\nfloat _gpu_erf(float x) {\n  float ax = abs(x);\n  float t = 1.0 / (1.0 + 0.3275911 * ax);\n  float y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  float result = 1.0 - y * exp(-ax * ax);\n  return x < 0.0 ? -result : result;\n}\n\nfloat _gpu_erfinv(float x) {\n  float pi = 3.14159265358979;\n  float x2 = x * x;\n  float x3 = x * x2;\n  float x5 = x3 * x2;\n  float x7 = x5 * x2;\n  float x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
+export declare const GPU_ERF_PREAMBLE_GLSL = "\nfloat _gpu_erf(float x) {\n  float ax = abs(x);\n  float t = 1.0 / (1.0 + 0.3275911 * ax);\n  float y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  float result = 1.0 - y * exp(-ax * ax);\n  return x < 0.0 ? -result : result;\n}\n\nfloat _gpu_erfinv(float x) {\n  float pi = 3.14159265358979;\n  float x2 = x * x;\n  float x3 = x * x2;\n  float x5 = x3 * x2;\n  float x7 = x5 * x2;\n  float x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
+/**
+ * GPU error function preamble (WGSL syntax). See GPU_GAMMA_PREAMBLE_WGSL.
+ */
+export declare const GPU_ERF_PREAMBLE_WGSL = "\nfn _gpu_erf(x: f32) -> f32 {\n  let ax = abs(x);\n  let t = 1.0 / (1.0 + 0.3275911 * ax);\n  let y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  let result = 1.0 - y * exp(-ax * ax);\n  if (x < 0.0) { return -result; }\n  return result;\n}\n\nfn _gpu_erfinv(x: f32) -> f32 {\n  let pi = 3.14159265358979;\n  let x2 = x * x;\n  let x3 = x * x2;\n  let x5 = x3 * x2;\n  let x7 = x5 * x2;\n  let x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
 /**
  * GPU Heaviside step function preamble (GLSL syntax).
  * Returns 0 for x<0, 0.5 at x=0, 1 for x>0.
@@ -120,6 +130,49 @@ 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";
+/**
+ * GPU GCD preamble (GLSL syntax).
+ * Euclidean algorithm over floats; works for integer-valued inputs.
+ */
+export declare const GPU_GCD_PREAMBLE_GLSL = "\nfloat _gpu_gcd(float a, float b) {\n  a = abs(a); b = abs(b);\n  for (int i = 0; i < 32; i++) {\n    if (b < 0.5) break;\n    float t = mod(a, b);\n    a = b;\n    b = t;\n  }\n  return a;\n}\n";
+/**
+ * GPU GCD preamble (WGSL syntax).
+ */
+export declare const GPU_GCD_PREAMBLE_WGSL = "\nfn _gpu_gcd(a_in: f32, b_in: f32) -> f32 {\n  var a = abs(a_in); var b = abs(b_in);\n  for (var i: i32 = 0; i < 32; i++) {\n    if (b < 0.5) { break; }\n    let t = a % b;\n    a = b;\n    b = t;\n  }\n  return a;\n}\n";
+/**
+ * GPU Random preamble (GLSL syntax).
+ *
+ * Deterministic pseudorandom in [0, 1) from a float seed.
+ * Standard fract-sin hash; reproducible across runs for the same seed.
+ * Note: this hash exhibits visible banding near seed ≈ kπ for integer k.
+ * For high-quality shader random, callers should use a more robust hash
+ * (e.g. PCG or xxHash) and pre-seed it appropriately.
+ */
+export declare const GPU_RANDOM_PREAMBLE_GLSL = "\n// Deterministic pseudorandom in [0, 1) from a float seed.\n// Standard fract-sin hash; reproducible across runs for the same seed.\n// Note: this hash exhibits visible banding near seed \u2248 k\u03C0 for integer k.\n// For high-quality shader random, callers should use a more robust hash\n// (e.g. PCG or xxHash) and pre-seed it appropriately.\nfloat _gpu_random(float seed) {\n  return fract(sin(seed * 12.9898) * 43758.5453);\n}\n";
+/**
+ * GPU Random preamble (WGSL syntax).
+ *
+ * Deterministic pseudorandom in [0, 1) from a float seed.
+ * Standard fract-sin hash; reproducible across runs for the same seed.
+ * Note: this hash exhibits visible banding near seed ≈ kπ for integer k.
+ * For high-quality shader random, callers should use a more robust hash
+ * (e.g. PCG or xxHash) and pre-seed it appropriately.
+ */
+export declare const GPU_RANDOM_PREAMBLE_WGSL = "\n// Deterministic pseudorandom in [0, 1) from a float seed.\n// Standard fract-sin hash; reproducible across runs for the same seed.\n// Note: this hash exhibits visible banding near seed \u2248 k\u03C0 for integer k.\n// For high-quality shader random, callers should use a more robust hash\n// (e.g. PCG or xxHash) and pre-seed it appropriately.\nfn _gpu_random(seed: f32) -> f32 {\n  return fract(sin(seed * 12.9898) * 43758.5453);\n}\n";
+/**
+ * GPU Median preamble (GLSL syntax).
+ *
+ * One function per supported list size (2..8) using sorting networks.
+ * Each function takes N float arguments and returns the median via a
+ * Batcher odd-even merge sort encoded entirely as min/max calls.
+ */
+export declare const GPU_MEDIAN_PREAMBLE_GLSL = "\nfloat _gpu_median_2(float a, float b) {\n  return (a + b) * 0.5;\n}\nfloat _gpu_median_3(float a, float b, float c) {\n  return max(min(a, b), min(max(a, b), c));\n}\nfloat _gpu_median_4(float a, float b, float c, float d) {\n  float lo = max(min(a, b), min(c, d));\n  float hi = min(max(a, b), max(c, d));\n  return (lo + hi) * 0.5;\n}\nfloat _gpu_median_5(float a, float b, float c, float d, float e) {\n  // 9-comparator Bose-Nelson sort; v2 holds the median.\n  float t; float v0=a,v1=b,v2=c,v3=d,v4=e;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v0,v3); v3=max(v0,v3); v0=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v4); v4=max(v1,v4); v1=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  return v2;\n}\nfloat _gpu_median_6(float a, float b, float c, float d, float e, float f) {\n  float t; float v0=a,v1=b,v2=c,v3=d,v4=e,v5=f;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v4,v5); v5=max(v4,v5); v4=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v0,v4); v4=max(v0,v4); v0=t;\n  t=min(v1,v5); v5=max(v1,v5); v1=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  t=min(v3,v5); v5=max(v3,v5); v3=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  return (v2 + v3) * 0.5;\n}\nfloat _gpu_median_7(float a, float b, float c, float d, float e, float f, float g) {\n  float t; float v0=a,v1=b,v2=c,v3=d,v4=e,v5=f,v6=g;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v4,v5); v5=max(v4,v5); v4=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v4,v6); v6=max(v4,v6); v4=t;\n  t=min(v0,v4); v4=max(v0,v4); v0=t;\n  t=min(v1,v5); v5=max(v1,v5); v1=t;\n  t=min(v2,v6); v6=max(v2,v6); v2=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  t=min(v3,v5); v5=max(v3,v5); v3=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  return v3;\n}\nfloat _gpu_median_8(float a, float b, float c, float d, float e, float f, float g, float h) {\n  float t; float v0=a,v1=b,v2=c,v3=d,v4=e,v5=f,v6=g,v7=h;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v4,v5); v5=max(v4,v5); v4=t;\n  t=min(v6,v7); v7=max(v6,v7); v6=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v4,v6); v6=max(v4,v6); v4=t;\n  t=min(v5,v7); v7=max(v5,v7); v5=t;\n  t=min(v0,v4); v4=max(v0,v4); v0=t;\n  t=min(v1,v5); v5=max(v1,v5); v1=t;\n  t=min(v2,v6); v6=max(v2,v6); v2=t;\n  t=min(v3,v7); v7=max(v3,v7); v3=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  t=min(v5,v6); v6=max(v5,v6); v5=t;\n  t=min(v3,v5); v5=max(v3,v5); v3=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  return (v3 + v4) * 0.5;\n}\n";
+/**
+ * GPU Median preamble (WGSL syntax).
+ *
+ * Same sorting-network logic as the GLSL version with WGSL syntax.
+ */
+export declare const GPU_MEDIAN_PREAMBLE_WGSL = "\nfn _gpu_median_2(a: f32, b: f32) -> f32 {\n  return (a + b) * 0.5;\n}\nfn _gpu_median_3(a: f32, b: f32, c: f32) -> f32 {\n  return max(min(a, b), min(max(a, b), c));\n}\nfn _gpu_median_4(a: f32, b: f32, c: f32, d: f32) -> f32 {\n  let lo = max(min(a, b), min(c, d));\n  let hi = min(max(a, b), max(c, d));\n  return (lo + hi) * 0.5;\n}\nfn _gpu_median_5(a: f32, b: f32, c: f32, d: f32, e: f32) -> f32 {\n  // 9-comparator Bose-Nelson sort; v2 holds the median.\n  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var t: f32;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v0,v3); v3=max(v0,v3); v0=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v4); v4=max(v1,v4); v1=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  return v2;\n}\nfn _gpu_median_6(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32) -> f32 {\n  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var v5=f; var t: f32;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v4,v5); v5=max(v4,v5); v4=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v0,v4); v4=max(v0,v4); v0=t;\n  t=min(v1,v5); v5=max(v1,v5); v1=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  t=min(v3,v5); v5=max(v3,v5); v3=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  return (v2 + v3) * 0.5;\n}\nfn _gpu_median_7(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32, g: f32) -> f32 {\n  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var v5=f; var v6=g; var t: f32;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v4,v5); v5=max(v4,v5); v4=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v4,v6); v6=max(v4,v6); v4=t;\n  t=min(v0,v4); v4=max(v0,v4); v0=t;\n  t=min(v1,v5); v5=max(v1,v5); v1=t;\n  t=min(v2,v6); v6=max(v2,v6); v2=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  t=min(v3,v5); v5=max(v3,v5); v3=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  return v3;\n}\nfn _gpu_median_8(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32, g: f32, h: f32) -> f32 {\n  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var v5=f; var v6=g; var v7=h; var t: f32;\n  t=min(v0,v1); v1=max(v0,v1); v0=t;\n  t=min(v2,v3); v3=max(v2,v3); v2=t;\n  t=min(v4,v5); v5=max(v4,v5); v4=t;\n  t=min(v6,v7); v7=max(v6,v7); v6=t;\n  t=min(v0,v2); v2=max(v0,v2); v0=t;\n  t=min(v1,v3); v3=max(v1,v3); v1=t;\n  t=min(v4,v6); v6=max(v4,v6); v4=t;\n  t=min(v5,v7); v7=max(v5,v7); v5=t;\n  t=min(v0,v4); v4=max(v0,v4); v0=t;\n  t=min(v1,v5); v5=max(v1,v5); v1=t;\n  t=min(v2,v6); v6=max(v2,v6); v2=t;\n  t=min(v3,v7); v7=max(v3,v7); v3=t;\n  t=min(v1,v2); v2=max(v1,v2); v1=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  t=min(v5,v6); v6=max(v5,v6); v5=t;\n  t=min(v3,v5); v5=max(v3,v5); v3=t;\n  t=min(v2,v4); v4=max(v2,v4); v2=t;\n  t=min(v3,v4); v4=max(v3,v4); v3=t;\n  return (v3 + v4) * 0.5;\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.57.0 */
+/* 0.59.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic
@@ -61,9 +61,9 @@ export declare class ComputeEngineIntervalFunction extends Function {
         gammaln: typeof import("../interval").gammaln;
         factorial: typeof import("../interval").factorial;
         factorial2: typeof import("../interval").factorial2;
-        binomial: typeof import("../interval/elementary").binomial;
-        gcd: typeof import("../interval/elementary").gcd;
-        lcm: typeof import("../interval/elementary").lcm;
+        binomial: typeof import("../interval").binomial;
+        gcd: typeof import("../interval").gcd;
+        lcm: typeof import("../interval").lcm;
         chop: typeof import("../interval/elementary").chop;
         erf: typeof import("../interval/elementary").erf;
         erfc: typeof import("../interval/elementary").erfc;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Source code in the target language
  */

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.0 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _precision;

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

@@ -1,7 +1,8 @@
-/* 0.57.0 */
+/* 0.59.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;
+    private _maxCollectionSize;
     private _deadline;
     private _isVerifying;
     get timeLimit(): number;
@@ -10,6 +11,8 @@
     set iterationLimit(value: number);
     get recursionLimit(): number;
     set recursionLimit(value: number);
+    get maxCollectionSize(): number;
+    set maxCollectionSize(value: number);
     get deadline(): number | undefined;
     set deadline(value: number | undefined);
     get timeRemaining(): number;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.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,6 +1,14 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
- * Internal holder for simplification rules and their cache-staleness marker.
+ * Internal holder for a rule array and its cache-staleness marker.
+ *
+ * Despite its name, this class is rule-agnostic and backs all three
+ * engine rule stores: `ce.simplificationRules`, `ce.solveRules` and
+ * `ce.harmonizationRules`.
+ *
+ * Note: mutation detection is length-based, so a same-length in-place
+ * element replacement is not detected. Use the property setter (full
+ * replacement) for that.
  *
  * @internal
  */

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.0 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

package/dist/types/compute-engine/fungrim/loader.d.ts

@@ -0,0 +1,13 @@
+/* 0.59.0 */
+import type { FungrimLoadOptions, FungrimLoadReport, FungrimRuleData } from './types';
+/** The compiled artifact (the whole slice, bundled as JSON). */
+export declare const FUNGRIM_CORE: FungrimRuleData;
+/**
+ * Load the compiled Fungrim identities into a Compute Engine instance.
+ *
+ * Synchronous and idempotent per engine: a second call with an overlapping
+ * selection skips the already-loaded rule ids. Shell declarations go into
+ * the **current** scope — call `loadIdentities` before declaring user
+ * symbols that could shadow shell heads.
+ */
+export declare function loadIdentities(ce: IComputeEngine, options?: FungrimLoadOptions): FungrimLoadReport;

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

@@ -0,0 +1,160 @@
+/* 0.59.0 */
+import type { BoxedSubstitution } from '../types-serialization';
+/** Raw MathJSON — the artifact is plain JSON. */
+export type FungrimMathJson = unknown;
+/**
+ * A declarative guard specification, compiled offline from a corpus entry's
+ * assumptions (FUNGRIM-PLAN-5-LOADER.md §2.2). The runtime loader turns each
+ * spec into a tri-valued condition closure; every predicate must return a
+ * definitive positive for the rule to fire (fail-closed).
+ */
+export type GuardSpec = {
+    k: 'type';
+    wc: string;
+    t: 'integer' | 'real' | 'rational' | 'complex';
+} | {
+    k: 'cmp';
+    wc: string;
+    op: 'gt' | 'ge' | 'lt' | 'le';
+    bound: FungrimMathJson;
+}
+/**
+ * Phase 3: comparison over a part extractor of the substituted value —
+ * `Greater(Re(z), 0)`, `Less(Abs(q), 1)`, `Element(Im(z), Interval(a,b))`.
+ * Literal substitutions fold numerically; symbol substitutions consult the
+ * Track-3 part-bound assumption facts.
+ */
+ | {
+    k: 'part-cmp';
+    wc: string;
+    part: 're' | 'im' | 'abs' | 'arg';
+    op: 'gt' | 'ge' | 'lt' | 'le';
+    bound: FungrimMathJson;
+}
+/**
+ * Phase 3: membership in an inert or compound set (`HH`, explicit
+ * `Set(…)`, `Union(…)`). Fires only on a literal `True` from the Element
+ * evaluation — for inert shells like `HH` (no `contains` handler) that is
+ * the Track-3 stored-membership exact-match path
+ * (`assume(Element(tau, HH))`); literals can never discharge those.
+ */
+ | {
+    k: 'member';
+    wc: string;
+    set: FungrimMathJson;
+} | {
+    k: 'ne';
+    lhs: FungrimMathJson;
+    rhs: FungrimMathJson;
+} | {
+    k: 'eval';
+    pred: FungrimMathJson;
+};
+/** Corpus entry class of a compiled rule. */
+export type FungrimRuleClass = 'specific-value' | 'identity';
+/** Which engine rule store a compiled rule is routed to. */
+export type FungrimRuleTarget = 'simplify' | 'solve' | 'harmonization';
+/**
+ * One compiled rule record from the artifact. `match`/`replace` are stored
+ * in CANONICAL-form MathJSON: the loader must box them canonically (in a
+ * scope where the wildcards carry their guard-implied types) before handing
+ * them to the engine.
+ */
+export type CompiledFungrimRule = {
+    /** `'fungrim:<entry-id>'` — surfaces in `simplify()` steps' `because`. */
+    id: string;
+    match: FungrimMathJson;
+    replace: FungrimMathJson;
+    guards: GuardSpec[];
+    purpose: RulePurpose;
+    target: FungrimRuleTarget;
+    class: FungrimRuleClass;
+    /** Heads referenced by the rule (for shell pruning and diagnostics). */
+    heads: string[];
+    /** Corpus topics (for load-time filtering). */
+    topics: string[];
+};
+/** A pruned shell declaration: a head referenced by the compiled rules that
+ *  is not a Compute Engine built-in. */
+export type FungrimShellDeclaration = {
+    signature: string;
+    description?: string;
+    arity?: number | number[];
+};
+/** Provenance and compile-time statistics baked into the artifact. */
+export type FungrimManifest = {
+    schemaVersion: number;
+    generator: string;
+    upstream: {
+        name: string;
+        snapshotSha256: string | null;
+        translator: string | null;
+    };
+    slice: {
+        classes: string[];
+        guardLevels: string[];
+        entries: number;
+    };
+    counts: {
+        rules: number;
+        byPurpose: Record<string, number>;
+        byClass: Record<string, number>;
+        byTarget: Record<string, number>;
+    };
+    /** Offline skip counts by reason (guard-uncompilable, compat-signature,
+     *  wildcard-loss, no-fire, duplicate-undirected, lhs-not-value-form, …). */
+    ledger: Record<string, number>;
+};
+/** The shape of the compiled artifact (`fungrim-core-data.json`). */
+export type FungrimRuleData = {
+    manifest: FungrimManifest;
+    declarations: Record<string, FungrimShellDeclaration>;
+    rules: CompiledFungrimRule[];
+};
+/**
+ * Debug hook invoked when a rule's condition fails specifically because a
+ * guard predicate returned `undefined` (unknown) — as opposed to a
+ * definitive negative. Converts "the rule silently didn't fire" into an
+ * actionable trace (FUNGRIM-PLAN-5-LOADER.md §2.8).
+ */
+export type FungrimGuardUndecidedHandler = (ruleId: string, wildcards: BoxedSubstitution) => void;
+/** Options for `loadIdentities()` (FUNGRIM-PLAN-5-LOADER.md §2.1). */
+export type FungrimLoadOptions = {
+    /** Only load rules tagged with at least one of these corpus topics. */
+    topics?: ReadonlyArray<string>;
+    /** Only load rules of these classes. */
+    classes?: ReadonlyArray<FungrimRuleClass>;
+    /** Only load rules with these purposes. */
+    purposes?: ReadonlyArray<RulePurpose>;
+    /** When `true`, rules targeting the solve/harmonization stores are routed
+     *  to `ce.solveRules`/`ce.harmonizationRules`. **Default**: `false`
+     *  (such rules are skipped with reason `'solve-disabled'`). */
+    solve?: boolean;
+    /** Debug hook for guard predicates that return `undefined`. */
+    onGuardUndecided?: FungrimGuardUndecidedHandler;
+    /** Alternate compiled artifact (testing, future per-family data modules).
+     *  **Default**: the bundled `FUNGRIM_CORE` artifact. */
+    data?: FungrimRuleData;
+};
+/** The report returned by `loadIdentities()` (FUNGRIM-PLAN-5-LOADER.md §2.8). */
+export type FungrimLoadReport = {
+    /** Number of rules registered by this call. */
+    loaded: number;
+    byTarget: Record<FungrimRuleTarget, number>;
+    byPurpose: Record<RulePurpose, number>;
+    /** Shell heads newly declared in the current scope by this call. */
+    declared: string[];
+    /** Runtime skips: selection filters, already-loaded ids, boxing failures
+     *  in the user's environment. */
+    skipped: {
+        id: string;
+        reason: string;
+    }[];
+    /** Baked-in offline skip counts by reason, from the artifact manifest —
+     *  what the *corpus* contains vs. what this artifact can do. */
+    compileLedger: Record<string, number>;
+};
+export type IdentitiesLoadOptions = FungrimLoadOptions;
+export type IdentitiesLoadReport = FungrimLoadReport;
+export type IdentitiesRuleData = FungrimRuleData;
+export type IdentitiesGuardUndecidedHandler = FungrimGuardUndecidedHandler;

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

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