@cortex-js/compute-engine 0.60.0 → 0.61.0

package/dist/types/common/type/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type

package/dist/types/common/type/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export { isValidType };
 export { widen, narrow } from './subtype';
 import type { Type, FunctionSignature, TypeString } from './types';

package/dist/types/common/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  *
  * <!--
  * !@consider?

package/dist/types/compile.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export { compile } from './compute-engine/compilation/compile-expression';
 export { JavaScriptTarget } from './compute-engine/compilation/javascript-target';
 export { GPUShaderTarget } from './compute-engine/compilation/gpu-target';
@@ -6,5 +6,6 @@ export { GLSLTarget } from './compute-engine/compilation/glsl-target';
 export { WGSLTarget } from './compute-engine/compilation/wgsl-target';
 export { PythonTarget } from './compute-engine/compilation/python-target';
 export { IntervalJavaScriptTarget } from './compute-engine/compilation/interval-javascript-target';
+export { IntervalGLSLTarget } from './compute-engine/compilation/interval-glsl-target';
 export { BaseCompiler } from './compute-engine/compilation/base-compiler';
 export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, ExecutableTarget, ComplexResult, CompiledRunner, ExpressionRunner, LambdaRunner, LanguageTarget, TargetSource, CompiledFunction, } from './compute-engine/compilation/types';

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

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { type Subject } from './boxed-expression/constraint-subject';
 /**
  * Add an assumption, in the form of a predicate, for example:

package/dist/types/compute-engine/boxed-expression/abstract-boxed-expression.d.ts

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

package/dist/types/compute-engine/boxed-expression/apply.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BigDecimal } from '../../big-decimal';
 import type { Expression } from '../global-types';
 export declare function apply(expr: Expression, fn: (x: number) => number | Complex, bigFn?: (x: BigDecimal) => BigDecimal | Complex | number, complexFn?: (x: Complex) => number | Complex): Expression | undefined;

package/dist/types/compute-engine/boxed-expression/arithmetic-add.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**

package/dist/types/compute-engine/boxed-expression/arithmetic-mul-div.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { NumericValue } from '../numeric-value/types';
 import type { Rational } from '../numerics/types';
 /**

package/dist/types/compute-engine/boxed-expression/arithmetic-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { Rational } from '../numerics/types';
 export declare function asRadical(expr: Expression): Rational | null;
 /**

package/dist/types/compute-engine/boxed-expression/ascii-math.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export type AsciiMathSerializer = (expr: Expression, precedence?: number) => string;
 export type AsciiMathOptions = {
     symbols: Record<string, string>;

package/dist/types/compute-engine/boxed-expression/box.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { FormOption } from '../types-serialization';
 import type { MathJsonSymbol } from '../../math-json/types';
 import { NumericValue } from '../numeric-value/types';

package/dist/types/compute-engine/boxed-expression/boxed-dictionary.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 import { DictionaryValue, MathJsonExpression } from '../../math-json/types';

package/dist/types/compute-engine/boxed-expression/boxed-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, Expression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, IComputeEngine as ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition, ExpressionInput, FunctionInterface } from '../global-types';
 import { Type } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';

package/dist/types/compute-engine/boxed-expression/boxed-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BigDecimal } from '../../big-decimal';
 import type { MathJsonExpression, MathJsonNumberObject } from '../../math-json';
 import type { Rational, SmallInteger } from '../numerics/types';

package/dist/types/compute-engine/boxed-expression/boxed-operator-definition.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { OperatorDefinition, Expression, BoxedOperatorDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, IComputeEngine as ComputeEngine, Scope, Sign } from '../global-types';
 export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition {

package/dist/types/compute-engine/boxed-expression/boxed-patterns.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * # Pattern Matching Wildcards
  *
  * Patterns can contain wildcards that match parts of expressions. There are

package/dist/types/compute-engine/boxed-expression/boxed-string.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 /**

package/dist/types/compute-engine/boxed-expression/boxed-symbol.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { Type, TypeString } from '../../common/type/types';
 import type { OneOf } from '../../common/one-of';
 import { BoxedType } from '../../common/type/boxed-type';

package/dist/types/compute-engine/boxed-expression/boxed-tensor.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { IComputeEngine as ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, Expression, SimplifyOptions, PatternMatchOptions, Tensor, TensorInterface } from '../global-types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { NumericValue } from '../numeric-value/types';

package/dist/types/compute-engine/boxed-expression/boxed-value-definition.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { ConfigurationChangeListener } from '../../common/configuration-change';

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

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
     value: T | null;
     generation: number | undefined;
 };

package/dist/types/compute-engine/boxed-expression/canonical-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * Ensure all expressions in the array are in canonical form
  */

package/dist/types/compute-engine/boxed-expression/canonical.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function canonicalForm(expr: Expression, forms: CanonicalOptions, scope?: Scope): Expression;

package/dist/types/compute-engine/boxed-expression/compare.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 type ExpandFn = (expr: Expression) => Expression;
 /** @internal */
 export declare function _setExpand(fn: ExpandFn): void;

package/dist/types/compute-engine/boxed-expression/constants.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Leaf module for shared constants used across boxed-expression modules.
  * No imports from sibling modules to avoid circular dependencies.
  */

package/dist/types/compute-engine/boxed-expression/constraint-subject.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * Constraint subjects (docs/fungrim/FUNGRIM-PLAN-3-ASSUMPTIONS.md §2).
  *

package/dist/types/compute-engine/boxed-expression/exp-to-trig.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * Rewrite exponentials of an imaginary argument to trigonometric form via
  * Euler's formula, `e^{i theta} -> cos(theta) + i sin(theta)`, throughout the

package/dist/types/compute-engine/boxed-expression/expand.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function choose(n: number, k: number): number;
 /** Attempt to transform the expression (h, ops) into a sum */
 export declare function expandFunction(ce: ComputeEngine, h: string, ops: ReadonlyArray<Expression>): Expression | null;

package/dist/types/compute-engine/boxed-expression/expression-map.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<Expression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [Expression, U])[]);

package/dist/types/compute-engine/boxed-expression/factor.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /** Combine rational expressions into a single fraction */
 export declare function together(op: Expression): Expression;
 /**

package/dist/types/compute-engine/boxed-expression/flatten.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  *
  * Optionally make all the arguments canonical (default).

package/dist/types/compute-engine/boxed-expression/hold.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /** Apply the function `f` to each operand of the expression `expr`,
  * account for the 'lazy' property of the operator definition:
  *

package/dist/types/compute-engine/boxed-expression/inequality-bounds.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { type Subject } from './constraint-subject';
 /**
  * Extract interval bounds for `symbol` from a condition expression.

package/dist/types/compute-engine/boxed-expression/init-lazy-refs.d.ts

@@ -1 +1 @@
-/* 0.60.0 */
+/* 0.61.0 */

package/dist/types/compute-engine/boxed-expression/invisible-operator.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function canonicalInvisibleOperator(ops: ReadonlyArray<Expression>, { engine: ce }: {
     engine: ComputeEngine;
 }): Expression | null;

package/dist/types/compute-engine/boxed-expression/match.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).

package/dist/types/compute-engine/boxed-expression/multivariate-gcd.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * Multivariate polynomial GCD over ℤ via **Brown's dense modular algorithm**
  * (ROADMAP B11, Stage B).

package/dist/types/compute-engine/boxed-expression/multivariate-poly.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * `MPoly` — a distributed, sparse **multivariate polynomial over ℤ**.
  *

package/dist/types/compute-engine/boxed-expression/negate.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function canonicalNegate(expr: Expression): Expression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an

package/dist/types/compute-engine/boxed-expression/numerics.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BigDecimal } from '../../big-decimal';
 import type { Rational } from '../numerics/types';
 import type { Expression, ExpressionInput } from '../global-types';

package/dist/types/compute-engine/boxed-expression/order.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 import { DEFAULT_COMPLEXITY } from './constants';
 export { DEFAULT_COMPLEXITY };

package/dist/types/compute-engine/boxed-expression/pattern-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Leaf module for wildcard pattern utility functions.
  *
  * These are extracted from boxed-patterns.ts to break circular dependencies:

package/dist/types/compute-engine/boxed-expression/polynomial-degree.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * The total degree of an expression is the sum of the
  * positive integer degrees of the factors in the expression:

package/dist/types/compute-engine/boxed-expression/polynomials.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export { totalDegree, maxDegree, lex, revlex } from './polynomial-degree';
 /**
  * Coefficient of a univariate (single variable) polynomial.

package/dist/types/compute-engine/boxed-expression/predicates.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function isPrime(expr: Expression): boolean | undefined;

package/dist/types/compute-engine/boxed-expression/rule-index.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Operator-indexed rule dispatch (docs/fungrim/FUNGRIM-PLAN-2-RULES.md §2.1, Feature A).
  *
  * This is an INTERNAL side table: the public `BoxedRuleSet` type is

package/dist/types/compute-engine/boxed-expression/rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;

package/dist/types/compute-engine/boxed-expression/serialize.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { IComputeEngine as ComputeEngine, Expression, JsonSerializationOptions } from '../global-types';
 interface ProductLike {
     asRationalExpression(): Expression;

package/dist/types/compute-engine/boxed-expression/sgn.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function sgn(expr: Expression): Sign | undefined;
 /**
  * Sign `s` is > 0.

package/dist/types/compute-engine/boxed-expression/simplify.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

package/dist/types/compute-engine/boxed-expression/solve-linear-system.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * Solve a system of linear equations.
  *

package/dist/types/compute-engine/boxed-expression/solve.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * MathJsonExpression is a function of a single variable (`x`) or an Equality

package/dist/types/compute-engine/boxed-expression/stochastic-equal.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 type ComplexResult = {
     re: number;
     im: number;

package/dist/types/compute-engine/boxed-expression/trigonometry.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /** Assuming x in an expression in radians, convert to current angular unit. */
 export declare function radiansToAngle(x: Expression | undefined): Expression | undefined;
 export declare function evalTrig(name: string, op: Expression | undefined): Expression | undefined;

package/dist/types/compute-engine/boxed-expression/type-guards.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { NumericValue } from '../numeric-value/types';
 /** Preferred guard for runtime expressions. */
 export declare function isExpression(x: unknown): x is Expression;

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
 /**

package/dist/types/compute-engine/boxed-expression/validate.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.

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

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will

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

@@ -1,9 +1,16 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
  */
 export declare class BaseCompiler {
+    /**
+     * Precedence used when compiling a folded symbol value. Higher than any
+     * target's infix operator precedence, so a compound value parenthesizes
+     * itself when spliced into a surrounding expression. See
+     * `tryFoldKnownSymbol`.
+     */
+    private static readonly FOLD_OPERAND_PREC;
     /**
      * Compile an expression to target language source code
      */
@@ -121,6 +128,77 @@ export declare class BaseCompiler {
     static isIntegerValued(expr: Expression): boolean;
     /** True if the expression is provably non-negative (sign ≥ 0). */
     static isNonNegative(expr: Expression): boolean;
+    /**
+     * If `id` names a symbol that is *known* to the engine — it has an assigned
+     * value (`ce.assign("a", 1.5)`) or is a declared constant — return the
+     * compiled target code for that value, i.e. **fold** the value into the
+     * generated code the way `evaluate()` does. Returns `undefined` for a
+     * genuinely free symbol (no value), so the caller falls back to its
+     * free-symbol plumbing (a `vars` mapping, a `_.id` argument lookup, or a
+     * declarable identifier).
+     *
+     * This keeps the compiled output consistent with `expr.unknowns` and
+     * `evaluate()`: a symbol they treat as known (folded / dropped) is also
+     * folded by `compile()`, instead of being emitted as a bare, dangling
+     * reference (an undeclared GLSL identifier, or a bare JS global that throws
+     * `ReferenceError` at run time).
+     *
+     * Callers MUST resolve any `vars` mapping for `id` **before** calling this,
+     * so an explicitly `vars`-mapped symbol is never folded — the GPU/JS live
+     * path relies on a mapped symbol staying a per-frame uniform / argument.
+     *
+     * `target` is the in-flight target: nested symbols inside the value resolve
+     * through the same `vars`/constant/fold rules as the top-level expression.
+     *
+     * The value is compiled at a high precedence so a compound (operator) value
+     * self-parenthesizes: folding `b = c + 1` into `b * x` must yield
+     * `(c + 1) * x`, not `c + 1 * x`, and must stay safe when a handler splices
+     * the folded string into its own expression (e.g. `Power`'s `(code * code)`).
+     * An atomic value (number, symbol, function call) ignores the precedence, so
+     * no redundant parentheses are added in the common assigned-number case.
+     */
+    static tryFoldKnownSymbol(engine: ComputeEngine, id: string, target: CompileTarget<Expression>): string | undefined;
+    /**
+     * Operator heads the compiler lowers directly in `compileExpr`, independent
+     * of any target operator/function mapping (control-flow, binding, and
+     * indexing-set forms). `analyzeReferences` never reports these as
+     * "unsupported".
+     */
+    private static readonly STRUCTURAL_HEADS;
+    /**
+     * Analyze — without compiling, and never throwing — which external references
+     * the generated code for `expr` would have on `target`:
+     *
+     * - `freeSymbols`: identifiers the caller must supply at run time. These are
+     *   the free symbols *as codegen sees them*: symbols with no value in the
+     *   engine, after descending into the values of folded (assigned / constant)
+     *   symbols — so `a = b + 1` surfaces `b`, which `expr.unknowns` misses — and
+     *   after excluding bound variables (lambda parameters, indices of
+     *   `Sum`/`Product`/`Integrate`/`Loop`, `Block` locals). A `vars`-mapped
+     *   symbol is always included: the mapping makes it an external input even
+     *   when it also has an assigned value.
+     *
+     * - `unsupported`: operator heads with no operator/function mapping in the
+     *   target and not one of the structural forms above.
+     *
+     * Lets a caller validate that a compiled result is self-contained
+     * (`freeSymbols` covered by its inputs, `unsupported` empty) declaratively,
+     * instead of executing or GPU-compiling the code to discover a dangling
+     * reference or an unlowerable operator.
+     */
+    static analyzeReferences(expr: Expression, target: CompileTarget<Expression>, varsKeys?: ReadonlySet<string>): {
+        freeSymbols: string[];
+        unsupported: string[];
+    };
+    /**
+     * Attach `freeSymbols` / `unsupported` (from `analyzeReferences`) to a
+     * compilation result, returning the same object. Used by the built-in
+     * targets to make every result carry its declarative reference analysis.
+     */
+    static withReferences<R extends {
+        freeSymbols?: string[];
+        unsupported?: string[];
+    }>(result: R, expr: Expression, target: CompileTarget<Expression>, varsKeys?: ReadonlySet<string>): R;
     /**
      * Generate a temporary variable name
      */

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

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.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.60.0 */
+/* 0.61.0 */
  * Constant folding utilities for GPU compilation.
  *
  * These helpers allow compilation handlers to detect compile-time constants,

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

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**
@@ -8,7 +8,7 @@ import { GPUShaderTarget } from './gpu-target';
  * C-style function declarations, and `#version`-based shader structure.
  */
 export declare class GLSLTarget extends GPUShaderTarget {
-    protected readonly languageId = "glsl";
+    protected readonly languageId: string;
     protected getLanguageSpecificFunctions(): CompiledFunctions<Expression>;
     compileFunction(expr: Expression, functionName: string, returnType: string, parameters: Array<[name: string, type: string]>): string;
     compileShader(options: {

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

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -196,6 +196,12 @@ export declare const GPU_COLOR_PREAMBLE_GLSL = "\nfloat _gpu_srgb_to_linear(floa
  * their final color in `_gpu_oklch_to_srgb()`.
  */
 export declare const GPU_COLOR_PREAMBLE_WGSL = "\nfn _gpu_srgb_to_linear(c: f32) -> f32 {\n  if (c <= 0.04045) { return c / 12.92; }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn _gpu_linear_to_srgb(c: f32) -> f32 {\n  if (c <= 0.0031308) { return 12.92 * c; }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nfn _gpu_srgb_to_oklab(rgb: vec3f) -> vec3f {\n  let r = _gpu_srgb_to_linear(rgb.x);\n  let g = _gpu_srgb_to_linear(rgb.y);\n  let b = _gpu_srgb_to_linear(rgb.z);\n  let l_ = pow(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b, 1.0 / 3.0);\n  let m_ = pow(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b, 1.0 / 3.0);\n  let s_ = pow(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b, 1.0 / 3.0);\n  return vec3f(\n    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,\n    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,\n    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_\n  );\n}\n\nfn _gpu_oklab_to_srgb(lab: vec3f) -> vec3f {\n  let l_ = lab.x + 0.3963377774 * lab.y + 0.2158037573 * lab.z;\n  let m_ = lab.x - 0.1055613458 * lab.y - 0.0638541728 * lab.z;\n  let s_ = lab.x - 0.0894841775 * lab.y - 1.291485548 * lab.z;\n  let l = l_ * l_ * l_;\n  let m = m_ * m_ * m_;\n  let s = s_ * s_ * s_;\n  let r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;\n  let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;\n  let b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;\n  return clamp(vec3f(_gpu_linear_to_srgb(r), _gpu_linear_to_srgb(g), _gpu_linear_to_srgb(b)), vec3f(0.0), vec3f(1.0));\n}\n\nfn _gpu_oklab_to_oklch(lab: vec3f) -> vec3f {\n  let C = length(lab.yz);\n  var H = atan2(lab.z, lab.y) * (180.0 / 3.14159265359);\n  if (H < 0.0) { H = H + 360.0; }\n  return vec3f(lab.x, C, H);\n}\n\nfn _gpu_oklch_to_oklab(lch: vec3f) -> vec3f {\n  let h_rad = lch.z * (3.14159265359 / 180.0);\n  return vec3f(lch.x, lch.y * cos(h_rad), lch.y * sin(h_rad));\n}\n\nfn _gpu_srgb_to_oklch(rgb: vec3f) -> vec3f {\n  return _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb));\n}\n\nfn _gpu_oklch_to_srgb(lch: vec3f) -> vec3f {\n  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(lch));\n}\n\nfn _gpu_hsl_to_rgb(hsl: vec3f) -> vec3f {\n  let h = hsl.x;\n  let s = hsl.y;\n  let l = hsl.z;\n  let c = (1.0 - abs(2.0 * l - 1.0)) * s;\n  let h6 = h / 60.0;\n  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));\n  var r: f32 = 0.0;\n  var g: f32 = 0.0;\n  var b: f32 = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  let m = l - c / 2.0;\n  return vec3f(r + m, g + m, b + m);\n}\n\nfn _gpu_rgb_to_hsl(rgb: vec3f) -> vec3f {\n  let maxc = max(max(rgb.x, rgb.y), rgb.z);\n  let minc = min(min(rgb.x, rgb.y), rgb.z);\n  let l = (maxc + minc) / 2.0;\n  let d = maxc - minc;\n  if (d < 1e-6) { return vec3f(0.0, 0.0, l); }\n  let s = d / (1.0 - abs(2.0 * l - 1.0));\n  var h: f32;\n  if (maxc == rgb.x) {\n    let v = (rgb.y - rgb.z) / d;\n    h = v - 6.0 * floor(v / 6.0);\n  } else if (maxc == rgb.y) {\n    h = (rgb.z - rgb.x) / d + 2.0;\n  } else {\n    h = (rgb.x - rgb.y) / d + 4.0;\n  }\n  h = h * 60.0;\n  if (h < 0.0) { h = h + 360.0; }\n  return vec3f(h, s, l);\n}\n\nfn _gpu_hsv_to_rgb(hsv: vec3f) -> vec3f {\n  let h = hsv.x;\n  let s = hsv.y;\n  let v = hsv.z;\n  let c = v * s;\n  let h6 = h / 60.0;\n  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));\n  var r: f32 = 0.0;\n  var g: f32 = 0.0;\n  var b: f32 = 0.0;\n  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }\n  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }\n  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }\n  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }\n  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }\n  else               { r = c; g = 0.0; b = x; }\n  let m = v - c;\n  return vec3f(r + m, g + m, b + m);\n}\n\nfn _gpu_rgb_to_hsv(rgb: vec3f) -> vec3f {\n  let maxc = max(max(rgb.x, rgb.y), rgb.z);\n  let minc = min(min(rgb.x, rgb.y), rgb.z);\n  let v = maxc;\n  let d = maxc - minc;\n  if (d < 1e-6) { return vec3f(0.0, 0.0, v); }\n  var s: f32 = 0.0;\n  if (maxc >= 1e-6) { s = d / maxc; }\n  var h: f32;\n  if (maxc == rgb.x) {\n    let q = (rgb.y - rgb.z) / d;\n    h = q - 6.0 * floor(q / 6.0);\n  } else if (maxc == rgb.y) {\n    h = (rgb.z - rgb.x) / d + 2.0;\n  } else {\n    h = (rgb.x - rgb.y) / d + 4.0;\n  }\n  h = h * 60.0;\n  if (h < 0.0) { h = h + 360.0; }\n  return vec3f(h, s, v);\n}\n\nfn _gpu_color_mix(lch1: vec3f, lch2: vec3f, t: f32) -> vec3f {\n  let L = mix(lch1.x, lch2.x, t);\n  let C = mix(lch1.y, lch2.y, t);\n  let a1 = lch1.y < 1e-6;\n  let a2 = lch2.y < 1e-6;\n  var H: f32;\n  if (a1 && a2) {\n    H = lch1.z;\n  } else if (a1) {\n    H = lch2.z;\n  } else if (a2) {\n    H = lch1.z;\n  } else {\n    var dh = lch2.z - lch1.z;\n    if (dh > 180.0) { dh = dh - 360.0; }\n    if (dh < -180.0) { dh = dh + 360.0; }\n    H = lch1.z + dh * t;\n    if (H < 0.0) { H = H + 360.0; }\n    if (H >= 360.0) { H = H - 360.0; }\n  }\n  return vec3f(L, C, H);\n}\n\nfn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {\n  let bg = _gpu_oklch_to_srgb(lch_bg);\n  let fg = _gpu_oklch_to_srgb(lch_fg);\n  let bgR = _gpu_srgb_to_linear(bg.x);\n  let bgG = _gpu_srgb_to_linear(bg.y);\n  let bgB = _gpu_srgb_to_linear(bg.z);\n  let fgR = _gpu_srgb_to_linear(fg.x);\n  let fgG = _gpu_srgb_to_linear(fg.y);\n  let fgB = _gpu_srgb_to_linear(fg.z);\n  let bgY = 0.2126729 * bgR + 0.7151522 * bgG + 0.0721750 * bgB;\n  let fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;\n  let bgC = pow(bgY, 0.56);\n  let fgC = pow(fgY, 0.57);\n  let contrast = (bgC - fgC) * 1.14;\n  return contrast * 100.0;\n}\n";
+/**
+ * Format a number as a GPU float literal.
+ *
+ * Both GLSL and WGSL require float literals to have a decimal point.
+ */
+export declare function formatGPUNumber(n: number): string;
 /**
  * Abstract base class for GPU shader compilation targets.
  *