feat/refactor: 'expr.transform()'; fixes & refactors to 'replace()' and rule-application

.eslintrc.cjs

@@ -205,40 +205,34 @@ module.exports = {
           {
             target: './src/compute-engine/tensor/**',
             from: './src/compute-engine/symbolic/**',
-            message:
-              'tensor/ must not import from symbolic/.',
+            message: 'tensor/ must not import from symbolic/.',
           },
           {
             target: './src/compute-engine/tensor/**',
             from: './src/compute-engine/library/**',
-            message:
-              'tensor/ must not import from library/.',
+            message: 'tensor/ must not import from library/.',
           },
           {
             target: './src/compute-engine/tensor/**',
             from: './src/compute-engine/compilation/**',
-            message:
-              'tensor/ must not import from compilation/.',
+            message: 'tensor/ must not import from compilation/.',
           },
 
           // interval/ cannot import from symbolic/, library/, compilation/
           {
             target: './src/compute-engine/interval/**',
             from: './src/compute-engine/symbolic/**',
-            message:
-              'interval/ must not import from symbolic/.',
+            message: 'interval/ must not import from symbolic/.',
           },
           {
             target: './src/compute-engine/interval/**',
             from: './src/compute-engine/library/**',
-            message:
-              'interval/ must not import from library/.',
+            message: 'interval/ must not import from library/.',
           },
           {
             target: './src/compute-engine/interval/**',
             from: './src/compute-engine/compilation/**',
-            message:
-              'interval/ must not import from compilation/.',
+            message: 'interval/ must not import from compilation/.',
           },
 
           // Type definition files (types-*.ts) cannot import from implementation layers

src/compute-engine/boxed-expression/abstract-boxed-expression.ts

@@ -25,6 +25,7 @@ import type {
   JsonSerializationOptions,
   PatternMatchOptions,
   SimplifyOptions,
+  TransformOptions,
   IComputeEngine as ComputeEngine,
   Scope,
   Tensor,
@@ -38,6 +39,7 @@ import { toAsciiMath } from './ascii-math';
 // Dynamic import for serializeJson to avoid circular dependency
 import { cmp, eq, same } from './compare';
 import { CancellationError } from '../../common/interruptible';
+import { transform } from './transform';
 import { isSymbol, isString, isNumber, isFunction } from './type-guards';
 
 // Lazy reference to break circular dependency:
@@ -774,6 +776,10 @@ export abstract class _BoxedExpression implements Expression {
     return null;
   }
 
+  transform(options: TransformOptions): Expression | null {
+    return transform(this, options);
+  }
+
   has(_v: string | string[]): boolean {
     return false;
   }

src/compute-engine/boxed-expression/boxed-function.ts

@@ -1251,7 +1251,7 @@ export class BoxedFunction
 
       let evaluateFn: Expression | Promise<Expression> | undefined;
       try {
-        const opts = {
+        const opts: Partial<EvaluateOptions> & { engine?: ComputeEngine } = {
           numericApproximation,
           engine,
           signal: options?.signal,

src/compute-engine/boxed-expression/canonical.ts

@@ -75,7 +75,7 @@ export function canonicalForm(
   // Partial canonicalization produces a structural expression, not a fully
   // canonical one. This allows subsequent .canonical calls to perform full
   // canonicalization.
-  if (isFunction(expr) && expr.isCanonical) {
+  if (isFunction(expr) && forms.length > 0) {
     expr = expr.engine.function(expr.operator, [...expr.ops!], {
       form: 'structural',
     });