chore: fix dep issue

Author: arnog

src/common/type/subtype.ts

@@ -14,16 +14,8 @@ import type {
   TypeCompatibility,
   TypeString,
 } from './types';
-
-// Lazy import to break subtype → parse cycle
-let _parseType: typeof import('./parse').parseType | undefined;
-function lazyParseType(s: string): Type {
-  if (!_parseType) {
-    const m = './parse';
-    _parseType = require(m).parseType;
-  }
-  return _parseType!(s);
-}
+import { parseType } from './parse';
+import { widen } from './utils';
 
 /** For each key, *all* the primitive subtypes of the type corresponding to that key */
 const PRIMITIVE_SUBTYPES: Record<PrimitiveType, PrimitiveType[]> = {
@@ -119,12 +111,12 @@ export function isSubtype(
     typeof lhs === 'string' &&
     !PRIMITIVE_TYPES.includes(lhs as PrimitiveType)
   )
-    lhs = lazyParseType(lhs);
+    lhs = parseType(lhs);
   if (
     typeof rhs === 'string' &&
     !PRIMITIVE_TYPES.includes(rhs as PrimitiveType)
   )
-    rhs = lazyParseType(rhs);
+    rhs = parseType(rhs);
 
   // Every type is a subtype of `any`, the top type
   if (rhs === 'any') return true;
@@ -431,9 +423,6 @@ export function isSubtype(
       );
 
     if (lhs.kind === 'record') {
-      // Lazy import widen to break subtype → utils cycle
-      const m2 = './utils';
-      const { widen } = require(m2);
       return isSubtype(
         {
           kind: 'tuple',

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

@@ -51,6 +51,15 @@ import { cmp, eq, same } from './compare';
 import { CancellationError } from '../../common/interruptible';
 import { isSymbol, isString, isFunction } from './type-guards';
 
+// Lazy reference to break circular dependency:
+// serialize → numerics → utils → abstract-boxed-expression
+import type { serializeJson as _SerializeJsonFn } from './serialize';
+let _serializeJson: typeof _SerializeJsonFn;
+/** @internal */
+export function _setSerializeJson(fn: typeof _SerializeJsonFn) {
+  _serializeJson = fn;
+}
+
 /**
  * _BoxedExpression
  *
@@ -303,9 +312,7 @@ export abstract class _BoxedExpression implements Expression {
       metadata: defaultOptions.metadata,
     };
 
-    // Dynamic import to avoid circular dependency
-    const { serializeJson } = require('./serialize');
-    return serializeJson(this.engine, this, opts);
+    return _serializeJson(this.engine, this, opts);
   }
 
   print(): void {

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

@@ -8,8 +8,15 @@ import {
   isString,
   isTensor,
 } from './type-guards';
-// Dynamic import for expand to avoid circular dependency
-// (expand → arithmetic-add → boxed-tensor → abstract-boxed-expression → compare)
+
+// Lazy reference to break circular dependency:
+// expand → arithmetic-add → boxed-tensor → abstract-boxed-expression → compare
+import type { expand as _ExpandFn } from './expand';
+let _expand: typeof _ExpandFn;
+/** @internal */
+export function _setExpand(fn: typeof _ExpandFn) {
+  _expand = fn;
+}
 
 /**
  * Structural equality of boxed expressions.
@@ -129,9 +136,8 @@ export function eq(
     // If the expression have some unknowns, we only try to prove equality
     // if they have the same unknowns and are structurally equal after
     // expansing and simplification
-    const { expand } = require('./expand');
-    a = (expand(a) ?? a).simplify();
-    b = (expand(b) ?? b).simplify();
+    a = (_expand(a) ?? a).simplify();
+    b = (_expand(b) ?? b).simplify();
     if (!sameUnknowns(a, b)) return undefined;
     return same(a, b);
   }

src/compute-engine/boxed-expression/init-lazy-refs.ts

@@ -0,0 +1,16 @@
+// This module wires up lazy references that break circular dependencies.
+// Import it once from the main entry point (index.ts) so the registrations
+// run before any user code.
+
+import { expand } from './expand';
+import { _setExpand } from './compare';
+
+import { serializeJson } from './serialize';
+import { _setSerializeJson } from './abstract-boxed-expression';
+
+import { Product } from './product';
+import { _setProduct } from './serialize';
+
+_setExpand(expand);
+_setSerializeJson(serializeJson);
+_setProduct(Product);

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

@@ -27,12 +27,22 @@ import type {
   IComputeEngine as ComputeEngine,
   Metadata,
   Expression,
+  FunctionInterface,
   JsonSerializationOptions,
 } from '../global-types';
 import { isOperatorDef } from './utils';
 import { isNumber, isSymbol, isString, isFunction } from './type-guards';
 import { matchesNumber, matchesSymbol } from '../../math-json/utils';
 
+// Lazy reference to break circular dependency:
+// product → arithmetic-mul-div → ... → abstract-boxed-expression → serialize
+import type { Product as _ProductClass } from './product';
+let _Product: typeof _ProductClass;
+/** @internal */
+export function _setProduct(fn: typeof _ProductClass) {
+  _Product = fn;
+}
+
 function _escapeJsonString(s: undefined): undefined;
 function _escapeJsonString(s: string): string;
 function _escapeJsonString(s: string | undefined): string | undefined {
@@ -129,20 +139,13 @@ function serializePrettyJsonFunction(
   if (name === 'Multiply' && !exclusions.includes('Divide')) {
     // Display a product with negative exponents as a division if
     // there are terms with a negative degree.
-    // Dynamic require to avoid circular dependency:
-    // serialize → product → ... → abstract-boxed-expression → serialize
-    const { Product } = require('./product');
-    const result = new Product(ce, args, {
+    const result = new _Product(ce, args, {
       canonical: false,
     }).asRationalExpression();
-    if (result.operator === 'Divide')
-      return serializeJsonFunction(
-        ce,
-        result.operator,
-        result.ops!,
-        options,
-        metadata
-      );
+    if (result.operator === 'Divide') {
+      const ops = (result as Expression & FunctionInterface).ops;
+      return serializeJsonFunction(ce, result.operator, ops, options, metadata);
+    }
   }
 
   if (name === 'Power') {

src/compute-engine/compilation/glsl-target.ts

@@ -1,6 +1,7 @@
 import type { Expression } from '../global-types';
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
+import { BaseCompiler } from './base-compiler';
 
 /**
  * GLSL-specific function overrides.
@@ -42,9 +43,6 @@ export class GLSLTarget extends GPUShaderTarget {
     returnType: string,
     parameters: Array<[name: string, type: string]>
   ): string {
-    // Dynamic import to avoid circular dependency
-    const { BaseCompiler } = require('./base-compiler');
-
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
 

src/compute-engine/compilation/gpu-target.ts

@@ -8,6 +8,7 @@ import type {
   CompilationOptions,
   CompilationResult,
 } from './types';
+import { BaseCompiler } from './base-compiler';
 
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -303,8 +304,6 @@ export abstract class GPUShaderTarget implements LanguageTarget<Expression> {
     const allFunctions = this.getFunctions();
     const constants = this.getConstants();
 
-    // Dynamic import to avoid circular dependency
-    const { BaseCompiler } = require('./base-compiler');
 
     const target = this.createTarget({
       functions: (id) => {
@@ -330,8 +329,6 @@ export abstract class GPUShaderTarget implements LanguageTarget<Expression> {
     expr: Expression,
     _options: CompilationOptions<Expression> = {}
   ): string {
-    // Dynamic import to avoid circular dependency
-    const { BaseCompiler } = require('./base-compiler');
     const target = this.createTarget();
     return BaseCompiler.compile(expr, target);
   }

src/compute-engine/compilation/python-target.ts

@@ -8,6 +8,7 @@ import type {
   CompilationOptions,
   CompilationResult,
 } from './types';
+import { BaseCompiler } from './base-compiler';
 
 /**
  * Python operator mappings
@@ -348,8 +349,6 @@ export class PythonTarget implements LanguageTarget<Expression> {
     expr: Expression,
     _options: CompilationOptions<Expression> = {}
   ): string {
-    // Dynamic import to avoid circular dependency
-    const { BaseCompiler } = require('./base-compiler');
     const target = this.createTarget();
     const code = BaseCompiler.compile(expr, target);
 
@@ -378,8 +377,6 @@ export class PythonTarget implements LanguageTarget<Expression> {
     parameters: string[],
     docstring?: string
   ): string {
-    // Dynamic import to avoid circular dependency
-    const { BaseCompiler } = require('./base-compiler');
 
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
@@ -444,8 +441,6 @@ export class PythonTarget implements LanguageTarget<Expression> {
    * @param parameters - Parameter names
    */
   compileLambda(expr: Expression, parameters: string[]): string {
-    // Dynamic import to avoid circular dependency
-    const { BaseCompiler } = require('./base-compiler');
 
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);

src/compute-engine/compilation/wgsl-target.ts

@@ -1,6 +1,7 @@
 import type { Expression } from '../global-types';
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
+import { BaseCompiler } from './base-compiler';
 
 /**
  * WGSL-specific function overrides.
@@ -66,9 +67,6 @@ export class WGSLTarget extends GPUShaderTarget {
     returnType: string,
     parameters: Array<[name: string, type: string]>
   ): string {
-    // Dynamic import to avoid circular dependency
-    const { BaseCompiler } = require('./base-compiler');
-
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
 

src/compute-engine/index.ts

@@ -77,6 +77,7 @@ import { validatePattern } from './boxed-expression/boxed-patterns';
 import { BoxedString } from './boxed-expression/boxed-string';
 import { BoxedFunction } from './boxed-expression/boxed-function';
 import { _BoxedExpression } from './boxed-expression/abstract-boxed-expression';
+import './boxed-expression/init-lazy-refs';
 import { _BoxedOperatorDefinition } from './boxed-expression/boxed-operator-definition';
 import {
   HARMONIZATION_RULES,