smiles-js 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smiles-js",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A JavaScript library for building molecules using composable fragments",
   "type": "module",
   "main": "src/index.js",

package/src/constructors.js

@@ -510,7 +510,7 @@ export function RawFragment(smilesString) {
       };
     },
     toCode(varName = 'raw') {
-      return `const ${varName}1 = RawFragment(${JSON.stringify(smilesString)});`;
+      return `export const ${varName}1 = RawFragment(${JSON.stringify(smilesString)});`;
     },
     clone() {
       return RawFragment(smilesString);

package/src/decompiler.js

@@ -806,6 +806,10 @@ function decompileNode(node, indent, nextVar) {
 
 /**
  * Main decompile dispatcher - public API
+ * @param {Object} node - AST node to decompile
+ * @param {Object} options - Options
+ * @param {number} options.indent - Indentation level (default 0)
+ * @param {string} options.varName - Variable name prefix (default 'v')
  */
 export function decompile(node, options = {}) {
   const { indent = 0, varName = 'v' } = options;
@@ -813,5 +817,7 @@ export function decompile(node, options = {}) {
   const nextVar = createCounter(varName);
 
   const { code } = decompileNode(node, indentStr, nextVar);
-  return code;
+
+  // Always use export const
+  return code.replace(/^(\s*)const /gm, '$1export const ');
 }

package/src/decompiler.test.js

@@ -10,25 +10,25 @@ describe('Decompiler - Ring', () => {
   test('decompiles simple ring', () => {
     const benzene = Ring({ atoms: 'c', size: 6 });
     const code = decompile(benzene);
-    expect(code).toBe("const v1 = Ring({ atoms: 'c', size: 6 });");
+    expect(code).toBe("export const v1 = Ring({ atoms: 'c', size: 6 });");
   });
 
   test('decompiles ring with custom ring number', () => {
     const ring = Ring({ atoms: 'C', size: 6, ringNumber: 2 });
     const code = decompile(ring);
-    expect(code).toBe("const v1 = Ring({ atoms: 'C', size: 6, ringNumber: 2 });");
+    expect(code).toBe("export const v1 = Ring({ atoms: 'C', size: 6, ringNumber: 2 });");
   });
 
   test('decompiles ring with offset', () => {
     const ring = Ring({ atoms: 'C', size: 6, offset: 2 });
     const code = decompile(ring);
-    expect(code).toBe("const v1 = Ring({ atoms: 'C', size: 6, offset: 2 });");
+    expect(code).toBe("export const v1 = Ring({ atoms: 'C', size: 6, offset: 2 });");
   });
 
   test('uses toCode() method', () => {
     const benzene = Ring({ atoms: 'c', size: 6 });
-    expect(benzene.toCode()).toBe("const ring1 = Ring({ atoms: 'c', size: 6 });");
-    expect(benzene.toCode('r')).toBe("const r1 = Ring({ atoms: 'c', size: 6 });");
+    expect(benzene.toCode()).toBe("export const ring1 = Ring({ atoms: 'c', size: 6 });");
+    expect(benzene.toCode('r')).toBe("export const r1 = Ring({ atoms: 'c', size: 6 });");
   });
 });
 
@@ -36,19 +36,19 @@ describe('Decompiler - Linear', () => {
   test('decompiles simple linear chain', () => {
     const propane = Linear(['C', 'C', 'C']);
     const code = decompile(propane);
-    expect(code).toBe("const v1 = Linear(['C', 'C', 'C']);");
+    expect(code).toBe("export const v1 = Linear(['C', 'C', 'C']);");
   });
 
   test('decompiles linear with bonds', () => {
     const ethene = Linear(['C', 'C'], ['=']);
     const code = decompile(ethene);
-    expect(code).toBe("const v1 = Linear(['C', 'C'], ['=']);");
+    expect(code).toBe("export const v1 = Linear(['C', 'C'], ['=']);");
   });
 
   test('uses toCode() method', () => {
     const propane = Linear(['C', 'C', 'C']);
-    expect(propane.toCode()).toBe("const linear1 = Linear(['C', 'C', 'C']);");
-    expect(propane.toCode('c')).toBe("const c1 = Linear(['C', 'C', 'C']);");
+    expect(propane.toCode()).toBe("export const linear1 = Linear(['C', 'C', 'C']);");
+    expect(propane.toCode('c')).toBe("export const c1 = Linear(['C', 'C', 'C']);");
   });
 });
 
@@ -59,9 +59,9 @@ describe('Decompiler - FusedRing', () => {
     const fusedRing = ring1.fuse(ring2, 2);
 
     const code = decompile(fusedRing);
-    expect(code).toBe(`const v1 = Ring({ atoms: 'C', size: 10 });
-const v2 = Ring({ atoms: 'C', size: 6, ringNumber: 2, offset: 2 });
-const v3 = v1.fuse(v2, 2);`);
+    expect(code).toBe(`export const v1 = Ring({ atoms: 'C', size: 10 });
+export const v2 = Ring({ atoms: 'C', size: 6, ringNumber: 2, offset: 2 });
+export const v3 = v1.fuse(v2, 2);`);
   });
 
   test('uses toCode() method', () => {
@@ -70,9 +70,9 @@ const v3 = v1.fuse(v2, 2);`);
     const fusedRing = ring1.fuse(ring2, 1);
 
     const code = fusedRing.toCode();
-    expect(code).toBe(`const fusedRing1 = Ring({ atoms: 'C', size: 6 });
-const fusedRing2 = Ring({ atoms: 'C', size: 6, ringNumber: 2, offset: 1 });
-const fusedRing3 = fusedRing1.fuse(fusedRing2, 1);`);
+    expect(code).toBe(`export const fusedRing1 = Ring({ atoms: 'C', size: 6 });
+export const fusedRing2 = Ring({ atoms: 'C', size: 6, ringNumber: 2, offset: 1 });
+export const fusedRing3 = fusedRing1.fuse(fusedRing2, 1);`);
   });
 });
 
@@ -83,9 +83,9 @@ describe('Decompiler - Molecule', () => {
     const molecule = Molecule([propyl, benzene]);
 
     const code = decompile(molecule);
-    expect(code).toBe(`const v1 = Linear(['C', 'C', 'C']);
-const v2 = Ring({ atoms: 'c', size: 6 });
-const v3 = Molecule([v1, v2]);`);
+    expect(code).toBe(`export const v1 = Linear(['C', 'C', 'C']);
+export const v2 = Ring({ atoms: 'c', size: 6 });
+export const v3 = Molecule([v1, v2]);`);
   });
 
   test('uses toCode() method', () => {
@@ -94,9 +94,9 @@ const v3 = Molecule([v1, v2]);`);
     const molecule = Molecule([propyl, benzene]);
 
     const code = molecule.toCode();
-    expect(code).toBe(`const molecule1 = Linear(['C', 'C', 'C']);
-const molecule2 = Ring({ atoms: 'c', size: 6 });
-const molecule3 = Molecule([molecule1, molecule2]);`);
+    expect(code).toBe(`export const molecule1 = Linear(['C', 'C', 'C']);
+export const molecule2 = Ring({ atoms: 'c', size: 6 });
+export const molecule3 = Molecule([molecule1, molecule2]);`);
   });
 });
 
@@ -105,13 +105,13 @@ describe('Decompiler - Round-trip', () => {
     const benzene = Ring({ atoms: 'c', size: 6 });
     const code = benzene.toCode('r');
 
-    expect(code).toBe("const r1 = Ring({ atoms: 'c', size: 6 });");
+    expect(code).toBe("export const r1 = Ring({ atoms: 'c', size: 6 });");
   });
 
   test('preserves structure through decompile', () => {
     const propane = Linear(['C', 'C', 'C']);
     const code = propane.toCode('p');
 
-    expect(code).toBe("const p1 = Linear(['C', 'C', 'C']);");
+    expect(code).toBe("export const p1 = Linear(['C', 'C', 'C']);");
   });
 });

package/src/fragment.test.js

@@ -63,6 +63,6 @@ describe('Fragment', () => {
 
   test('toCode works on fragment', () => {
     const benzene = Fragment('c1ccccc1');
-    expect(benzene.toCode('v')).toBe("const v1 = Ring({ atoms: 'c', size: 6 });");
+    expect(benzene.toCode('v')).toBe("export const v1 = Ring({ atoms: 'c', size: 6 });");
   });
 });

package/test-integration/acetaminophen.test.js

@@ -3,25 +3,26 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 const ACETAMINOPHEN_SMILES = 'CC(=O)Nc1ccc(O)cc1';
 const PHENACETIN_SMILES = 'CC(=O)Nc1ccc(OCC)cc1';
 
-const ACETAMINOPHEN_CODE = `const v1 = Linear(['C', 'C', 'N']);
-const v2 = Linear(['O'], ['=']);
-const v3 = v1.attach(v2, 2);
-const v4 = Ring({ atoms: 'c', size: 6 });
-const v5 = Linear(['O']);
-const v6 = v4.attach(v5, 4);
-const v7 = Molecule([v3, v6]);`;
-
-const PHENACETIN_CODE = `const v1 = Linear(['C', 'C', 'N']);
-const v2 = Linear(['O'], ['=']);
-const v3 = v1.attach(v2, 2);
-const v4 = Ring({ atoms: 'c', size: 6 });
-const v5 = Linear(['O', 'C', 'C']);
-const v6 = v4.attach(v5, 4);
-const v7 = Molecule([v3, v6]);`;
+const ACETAMINOPHEN_CODE = `export const v1 = Linear(['C', 'C', 'N']);
+export const v2 = Linear(['O'], ['=']);
+export const v3 = v1.attach(v2, 2);
+export const v4 = Ring({ atoms: 'c', size: 6 });
+export const v5 = Linear(['O']);
+export const v6 = v4.attach(v5, 4);
+export const v7 = Molecule([v3, v6]);`;
+
+const PHENACETIN_CODE = `export const v1 = Linear(['C', 'C', 'N']);
+export const v2 = Linear(['O'], ['=']);
+export const v3 = v1.attach(v2, 2);
+export const v4 = Ring({ atoms: 'c', size: 6 });
+export const v5 = Linear(['O', 'C', 'C']);
+export const v6 = v4.attach(v5, 4);
+export const v7 = Molecule([v3, v6]);`;
 
 describe('Acetaminophen Integration Test', () => {
   test('parses acetaminophen', () => {
@@ -78,11 +79,12 @@ describe('Acetaminophen Integration Test', () => {
   test('generated code is valid JavaScript', () => {
     const ast = parse(ACETAMINOPHEN_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     let factory;
     expect(() => {
       // eslint-disable-next-line no-new-func
-      factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+      factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
@@ -90,12 +92,13 @@ describe('Acetaminophen Integration Test', () => {
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(ACETAMINOPHEN_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
-    const varMatch = code.match(/const (v\d+) = /g);
-    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/const (v\d+)/)[1] : 'v1';
+    const varMatch = code.match(/export const (v\d+) = /g);
+    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/export const (v\d+)/)[1] : 'v1';
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${lastVar};`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${lastVar};`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.smiles).toBe(ACETAMINOPHEN_SMILES);
@@ -157,12 +160,13 @@ describe('Phenacetin Integration Test', () => {
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(PHENACETIN_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
-    const varMatch = code.match(/const (v\d+) = /g);
-    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/const (v\d+)/)[1] : 'v1';
+    const varMatch = code.match(/export const (v\d+) = /g);
+    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/export const (v\d+)/)[1] : 'v1';
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${lastVar};`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${lastVar};`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.smiles).toBe(PHENACETIN_SMILES);

package/test-integration/adjuvant-analgesics.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 // Note: Parser normalizes some ring/branch patterns
 
@@ -56,19 +57,21 @@ describe('Adjuvant Analgesics', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/celecoxib.test.js

@@ -3,36 +3,37 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 const CELECOXIB_SMILES = 'CC1=CC=C(C=C1)C2=CC(=NN2C3=CC=C(C=C3)S(=O)(=O)N)C(F)(F)F';
 
-const CELECOXIB_CODE = `const v1 = Linear(['C']);
-const v2 = Ring({ atoms: 'C', size: 6 });
-const v3 = Ring({ atoms: 'C', size: 5, ringNumber: 2 });
-const v4 = v3.substitute(4, 'N');
-const v5 = v4.substitute(5, 'N');
-const v6 = Ring({ atoms: 'C', size: 6, ringNumber: 3 });
-const v7 = v5.fuse(v6, 0);
-const v8 = Linear(['C', 'F']);
-const v9 = Linear(['F']);
-const v10 = v8.attach(v9, 1);
-const v11 = Linear(['F']);
-const v12 = v10.attach(v11, 1);
-const v13 = Molecule([v1, v2, v7, v12]);`;
-
-const PYRAZOLE_PHENYL_CODE = `const v1 = Ring({ atoms: 'C', size: 5 });
-const v2 = v1.substitute(4, 'N');
-const v3 = v2.substitute(5, 'N');
-const v4 = Ring({ atoms: 'C', size: 6, ringNumber: 2 });
-const v5 = v3.fuse(v4, 0);
-const v6 = Linear(['C']);
-const v7 = Molecule([v5, v6]);`;
-
-const MINIMAL_SEQUENTIAL_CODE = `const v1 = Ring({ atoms: 'C', size: 4 });
-const v2 = Ring({ atoms: 'C', size: 4, ringNumber: 2 });
-const v3 = v1.fuse(v2, 0);
-const v4 = Linear(['C']);
-const v5 = Molecule([v3, v4]);`;
+const CELECOXIB_CODE = `export const v1 = Linear(['C']);
+export const v2 = Ring({ atoms: 'C', size: 6 });
+export const v3 = Ring({ atoms: 'C', size: 5, ringNumber: 2 });
+export const v4 = v3.substitute(4, 'N');
+export const v5 = v4.substitute(5, 'N');
+export const v6 = Ring({ atoms: 'C', size: 6, ringNumber: 3 });
+export const v7 = v5.fuse(v6, 0);
+export const v8 = Linear(['C', 'F']);
+export const v9 = Linear(['F']);
+export const v10 = v8.attach(v9, 1);
+export const v11 = Linear(['F']);
+export const v12 = v10.attach(v11, 1);
+export const v13 = Molecule([v1, v2, v7, v12]);`;
+
+const PYRAZOLE_PHENYL_CODE = `export const v1 = Ring({ atoms: 'C', size: 5 });
+export const v2 = v1.substitute(4, 'N');
+export const v3 = v2.substitute(5, 'N');
+export const v4 = Ring({ atoms: 'C', size: 6, ringNumber: 2 });
+export const v5 = v3.fuse(v4, 0);
+export const v6 = Linear(['C']);
+export const v7 = Molecule([v5, v6]);`;
+
+const MINIMAL_SEQUENTIAL_CODE = `export const v1 = Ring({ atoms: 'C', size: 4 });
+export const v2 = Ring({ atoms: 'C', size: 4, ringNumber: 2 });
+export const v3 = v1.fuse(v2, 0);
+export const v4 = Linear(['C']);
+export const v5 = Molecule([v3, v4]);`;
 
 describe('Celecoxib Investigation', () => {
   test('full molecule parse', () => {
@@ -158,9 +159,10 @@ describe('Celecoxib Code Round-Trip', () => {
   test('generated code produces expected AST when executed', () => {
     const ast = parse(CELECOXIB_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v13;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v13;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.type).toBe('molecule');
@@ -171,11 +173,12 @@ describe('Celecoxib Code Round-Trip', () => {
     const smiles = 'C1=CC(=NN1C2=CC=CC=C2)C';
     const ast = parse(smiles);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     expect(code).toBe(PYRAZOLE_PHENYL_CODE);
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v7;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v7;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.type).toBe('molecule');
@@ -186,11 +189,12 @@ describe('Celecoxib Code Round-Trip', () => {
     const smiles = 'C1CC(C1C2CCC2)C';
     const ast = parse(smiles);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     expect(code).toBe(MINIMAL_SEQUENTIAL_CODE);
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v5;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v5;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.type).toBe('molecule');

package/test-integration/endocannabinoids.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 // Note: Many cannabinoid SMILES are too complex for current parser
 // Only PEA works correctly
@@ -28,19 +29,21 @@ describe('Endocannabinoids', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/hypertension-medication.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 // Telmisartan is tested separately in telmisartan.test.js
 // Note: Parser normalizes para-substituted benzene patterns
@@ -45,19 +46,21 @@ describe('Hypertension Medications', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/ketoprofen-debug.test.js

@@ -3,25 +3,26 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
-const KETOPROFEN_CODE = `const v1 = Linear(['C', 'C', 'C', 'O']);
-const v2 = Ring({ atoms: 'c', size: 6 });
-const v3 = Linear(['C']);
-const v4 = Linear(['O'], ['=']);
-const v5 = v3.attach(v4, 1);
-const v6 = Ring({ atoms: 'c', size: 6, ringNumber: 2 });
-const v7 = Molecule([v2, v5, v6]);
-const v8 = v1.attach(v7, 2);
-const v9 = Linear(['O'], ['=']);
-const v10 = v8.attach(v9, 3);`;
+const KETOPROFEN_CODE = `export const v1 = Linear(['C', 'C', 'C', 'O']);
+export const v2 = Ring({ atoms: 'c', size: 6 });
+export const v3 = Linear(['C']);
+export const v4 = Linear(['O'], ['=']);
+export const v5 = v3.attach(v4, 1);
+export const v6 = Ring({ atoms: 'c', size: 6, ringNumber: 2 });
+export const v7 = Molecule([v2, v5, v6]);
+export const v8 = v1.attach(v7, 2);
+export const v9 = Linear(['O'], ['=']);
+export const v10 = v8.attach(v9, 3);`;
 
-const BIPHENYL_CODE = `const v1 = Linear(['C', 'C', 'C', 'O']);
-const v2 = Ring({ atoms: 'c', size: 6 });
-const v3 = Ring({ atoms: 'c', size: 6, ringNumber: 2 });
-const v4 = Molecule([v2, v3]);
-const v5 = v1.attach(v4, 2);
-const v6 = Linear(['O'], ['=']);
-const v7 = v5.attach(v6, 3);`;
+const BIPHENYL_CODE = `export const v1 = Linear(['C', 'C', 'C', 'O']);
+export const v2 = Ring({ atoms: 'c', size: 6 });
+export const v3 = Ring({ atoms: 'c', size: 6, ringNumber: 2 });
+export const v4 = Molecule([v2, v3]);
+export const v5 = v1.attach(v4, 2);
+export const v6 = Linear(['O'], ['=']);
+export const v7 = v5.attach(v6, 3);`;
 
 describe('Ketoprofen Debug', () => {
   test('analyze structure', () => {
@@ -49,9 +50,10 @@ describe('Ketoprofen Code Round-Trip', () => {
     const smiles = 'CC(c1cccc(c1)C(=O)c2ccccc2)C(=O)O';
     const ast = parse(smiles);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v10;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v10;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.type).toBe('linear');
@@ -69,9 +71,10 @@ describe('Ketoprofen Code Round-Trip', () => {
     const smiles = 'CC(c1ccccc1c2ccccc2)C(=O)O';
     const ast = parse(smiles);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v7;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v7;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.type).toBe('linear');

package/test-integration/local-anesthetics.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 // Note: Parser normalizes para-substituted benzene patterns
 
@@ -68,19 +69,21 @@ describe('Local Anesthetics', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/nabumetone-normalized.test.js

@@ -0,0 +1,53 @@
+import { describe, test, expect } from 'bun:test';
+import { Fragment } from '../src/fragment.js';
+import { parse } from '../src/parser.js';
+import {
+  Ring, Linear, Molecule,
+} from '../src/constructors.js';
+import { stripExports } from './utils.js';
+
+/**
+ * Test case for Nabumetone that demonstrates full closed-loop round-trip:
+ * SMILES -> parse -> toCode() -> execute code -> SMILES (same as input)
+ */
+describe('Nabumetone Normalized', () => {
+  const NABUMETONE_SMILES = 'c1cc2ccc(OC)cc2cc1CCC(=O)C';
+
+  const EXPECTED_CODE = `export const v1 = Ring({ atoms: 'c', size: 6 });
+export const v2 = Ring({ atoms: 'c', size: 6, ringNumber: 2, offset: 2 });
+export const v3 = Linear(['O', 'C']);
+export const v4 = v2.attach(v3, 4);
+export const v5 = v1.fuse(v4, 2);
+export const v6 = Linear(['C', 'C', 'C', 'C']);
+export const v7 = Linear(['O'], ['=']);
+export const v8 = v6.attach(v7, 3);
+export const v9 = Molecule([v5, v8]);`;
+
+  test('Fragment parses normalized nabumetone SMILES', () => {
+    const nabumetone = Fragment(NABUMETONE_SMILES);
+    expect(nabumetone.smiles).toBe(NABUMETONE_SMILES);
+  });
+
+  test('toCode generates expected code', () => {
+    const ast = parse(NABUMETONE_SMILES);
+    const code = ast.toCode('v');
+    expect(code).toBe(EXPECTED_CODE);
+  });
+
+  test('CLOSED LOOP: SMILES -> toCode() -> execute -> same SMILES', () => {
+    // Parse the SMILES
+    const ast = parse(NABUMETONE_SMILES);
+
+    // Generate code
+    const code = ast.toCode('v');
+
+    // Execute the generated code
+    const executableCode = stripExports(code);
+    // eslint-disable-next-line no-new-func
+    const factory = new Function('Ring', 'Linear', 'Molecule', `${executableCode}\nreturn v9;`);
+    const reconstructed = factory(Ring, Linear, Molecule);
+
+    // Verify we get back the original SMILES
+    expect(reconstructed.smiles).toBe(NABUMETONE_SMILES);
+  });
+});

package/test-integration/nsaids-otc.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 const MOLECULES = {
   Aspirin: {
@@ -50,19 +51,21 @@ describe('OTC NSAIDs', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/nsaids-prescription.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 // Note: Some complex SMILES don't round-trip correctly due to parser limitations
 // Using parser output for now - TODO: fix parser for complex ring systems
@@ -75,19 +76,21 @@ describe('Prescription NSAIDs', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/opioids.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 // Note: Some complex opioid SMILES don't round-trip correctly due to parser limitations
 // Parser output used where possible - some molecules are unstable
@@ -49,19 +50,21 @@ describe('Opioids', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/steroids.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 const MOLECULES = {
   Cortisone: {
@@ -60,19 +61,21 @@ describe('Steroids', () => {
       test('generated code is valid JavaScript', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         expect(() => {
           // eslint-disable-next-line no-new-func, no-new
-          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+          new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
         }).not.toThrow();
       });
 
       test('codegen round-trip produces expected output', () => {
         const ast = parse(data.smiles);
         const code = ast.toCode('v');
+        const executableCode = stripExports(code);
 
         // eslint-disable-next-line no-new-func
-        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${data.lastVar};`);
+        const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${data.lastVar};`);
         const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
         expect(reconstructed.type).toBe(data.expectedType);

package/test-integration/sulfonamide-debug.test.js

@@ -4,25 +4,25 @@ import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
 
-const SIMPLE_SULFONAMIDE_CODE = `const v1 = Ring({ atoms: 'C', size: 6 });
-const v2 = Linear(['S', 'N']);
-const v3 = Linear(['O'], ['=']);
-const v4 = v2.attach(v3, 1);
-const v5 = Linear(['O'], ['=']);
-const v6 = v4.attach(v5, 1);
-const v7 = Molecule([v1, v6]);`;
+const SIMPLE_SULFONAMIDE_CODE = `export const v1 = Ring({ atoms: 'C', size: 6 });
+export const v2 = Linear(['S', 'N']);
+export const v3 = Linear(['O'], ['=']);
+export const v4 = v2.attach(v3, 1);
+export const v5 = Linear(['O'], ['=']);
+export const v6 = v4.attach(v5, 1);
+export const v7 = Molecule([v1, v6]);`;
 
-const PYRAZOLE_SULFONAMIDE_CODE = `const v1 = Ring({ atoms: 'C', size: 5 });
-const v2 = v1.substitute(4, 'N');
-const v3 = v2.substitute(5, 'N');
-const v4 = Ring({ atoms: 'C', size: 6, ringNumber: 2 });
-const v5 = v3.fuse(v4, 0);
-const v6 = Linear(['C', 'F']);
-const v7 = Linear(['F']);
-const v8 = v6.attach(v7, 1);
-const v9 = Linear(['F']);
-const v10 = v8.attach(v9, 1);
-const v11 = Molecule([v5, v10]);`;
+const PYRAZOLE_SULFONAMIDE_CODE = `export const v1 = Ring({ atoms: 'C', size: 5 });
+export const v2 = v1.substitute(4, 'N');
+export const v3 = v2.substitute(5, 'N');
+export const v4 = Ring({ atoms: 'C', size: 6, ringNumber: 2 });
+export const v5 = v3.fuse(v4, 0);
+export const v6 = Linear(['C', 'F']);
+export const v7 = Linear(['F']);
+export const v8 = v6.attach(v7, 1);
+export const v9 = Linear(['F']);
+export const v10 = v8.attach(v9, 1);
+export const v11 = Molecule([v5, v10]);`;
 
 describe('Sulfonamide Debug', () => {
   test('simple sulfonamide', () => {
@@ -50,9 +50,10 @@ describe('Sulfonamide Code Round-Trip', () => {
     const smiles = 'C1=CC=C(C=C1)S(=O)(=O)N';
     const ast = parse(smiles);
     const code = ast.toCode('v');
+    const executableCode = code.replace(/^export /gm, '');
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v7;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v7;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.type).toBe('molecule');
@@ -70,9 +71,10 @@ describe('Sulfonamide Code Round-Trip', () => {
     const smiles = 'C1=CC(=NN1C2=CC=C(C=C2)S(=O)(=O)N)C(F)(F)F';
     const ast = parse(smiles);
     const code = ast.toCode('v');
+    const executableCode = code.replace(/^export /gm, '');
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v11;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v11;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(reconstructed.type).toBe('molecule');

package/test-integration/telmisartan.test.js

@@ -3,6 +3,7 @@ import { parse } from '../src/parser.js';
 import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
+import { stripExports } from './utils.js';
 
 const TELMISARTAN_SMILES = 'CCCC1=NC2=C(C=C(C=C2N1CC3=CC=C(C=C3)C4=CC=CC=C4C(=O)O)C5=NC6=CC=CC=C6N5C)C';
 // With bond preservation, double bonds are preserved in output
@@ -14,39 +15,39 @@ const BENZIMIDAZOLE_SMILES = 'c1nc2ccccc2n1';
 // from the original due to fundamental AST model limitations:
 // 1. Ring closures that span across branch depths can't be represented
 // 2. The main fused ring (1+2) has atoms at different depths in the original SMILES
-const TELMISARTAN_CODE_GENERATED = `const v1 = Linear(['C', 'C', 'C']);
-const v2 = Ring({ atoms: 'C', size: 5, bonds: ['=', null, '=', null, null] });
-const v3 = v2.substitute(2, 'N');
-const v4 = v3.substitute(5, 'N');
-const v5 = Ring({ atoms: 'C', size: 6, ringNumber: 2, offset: 2, bonds: ['=', null, '=', null, '=', null] });
-const v6 = Linear(['C', 'C'], ['=']);
-const v7 = Linear(['C', 'C', 'N', 'C'], ['=']);
-const v8 = Ring({ atoms: 'C', size: 6, ringNumber: 3, bonds: ['=', null, '=', null, '=', null] });
-const v9 = Ring({ atoms: 'C', size: 6, ringNumber: 4, bonds: ['=', null, '=', null, '=', null] });
-const v10 = Linear(['C', 'O']);
-const v11 = Linear(['O'], ['=']);
-const v12 = v10.attach(v11, 1);
-const v13 = v8.attach(v9, 4);
-const v14 = v13.attach(v12, 6);
-const v15 = Molecule([v7, v14]);
-const v16 = v6.attach(v15, 2);
-const v17 = Ring({ atoms: 'C', size: 5, ringNumber: 5, bonds: ['=', null, '=', null, null] });
-const v18 = v17.substitute(2, 'N');
-const v19 = v18.substitute(5, 'N');
-const v20 = Ring({ atoms: 'C', size: 6, ringNumber: 6, bonds: ['=', null, '=', null, '=', null] });
-const v21 = v19.fuse(v20, 2);
-const v22 = Linear(['C']);
-const v23 = Molecule([v16, v21, v22]);
-const v24 = v5.attach(v23, 2);
-const v25 = v4.fuse(v24, 2);
-const v26 = Linear(['C']);
-const v27 = Molecule([v1, v25, v26]);`;
-
-const BENZIMIDAZOLE_CODE = `const v1 = Ring({ atoms: 'c', size: 5 });
-const v2 = v1.substitute(2, 'n');
-const v3 = v2.substitute(5, 'n');
-const v4 = Ring({ atoms: 'c', size: 6, ringNumber: 2, offset: 2 });
-const v5 = v3.fuse(v4, 2);`;
+const TELMISARTAN_CODE_GENERATED = `export const v1 = Linear(['C', 'C', 'C']);
+export const v2 = Ring({ atoms: 'C', size: 5, bonds: ['=', null, '=', null, null] });
+export const v3 = v2.substitute(2, 'N');
+export const v4 = v3.substitute(5, 'N');
+export const v5 = Ring({ atoms: 'C', size: 6, ringNumber: 2, offset: 2, bonds: ['=', null, '=', null, '=', null] });
+export const v6 = Linear(['C', 'C'], ['=']);
+export const v7 = Linear(['C', 'C', 'N', 'C'], ['=']);
+export const v8 = Ring({ atoms: 'C', size: 6, ringNumber: 3, bonds: ['=', null, '=', null, '=', null] });
+export const v9 = Ring({ atoms: 'C', size: 6, ringNumber: 4, bonds: ['=', null, '=', null, '=', null] });
+export const v10 = Linear(['C', 'O']);
+export const v11 = Linear(['O'], ['=']);
+export const v12 = v10.attach(v11, 1);
+export const v13 = v8.attach(v9, 4);
+export const v14 = v13.attach(v12, 6);
+export const v15 = Molecule([v7, v14]);
+export const v16 = v6.attach(v15, 2);
+export const v17 = Ring({ atoms: 'C', size: 5, ringNumber: 5, bonds: ['=', null, '=', null, null] });
+export const v18 = v17.substitute(2, 'N');
+export const v19 = v18.substitute(5, 'N');
+export const v20 = Ring({ atoms: 'C', size: 6, ringNumber: 6, bonds: ['=', null, '=', null, '=', null] });
+export const v21 = v19.fuse(v20, 2);
+export const v22 = Linear(['C']);
+export const v23 = Molecule([v16, v21, v22]);
+export const v24 = v5.attach(v23, 2);
+export const v25 = v4.fuse(v24, 2);
+export const v26 = Linear(['C']);
+export const v27 = Molecule([v1, v25, v26]);`;
+
+const BENZIMIDAZOLE_CODE = `export const v1 = Ring({ atoms: 'c', size: 5 });
+export const v2 = v1.substitute(2, 'n');
+export const v3 = v2.substitute(5, 'n');
+export const v4 = Ring({ atoms: 'c', size: 6, ringNumber: 2, offset: 2 });
+export const v5 = v3.fuse(v4, 2);`;
 
 describe('Telmisartan Integration Test', () => {
   test('parses telmisartan', () => {
@@ -107,11 +108,12 @@ describe('Telmisartan Integration Test', () => {
   test('generated code is valid JavaScript', () => {
     const ast = parse(TELMISARTAN_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     let factory;
     expect(() => {
       // eslint-disable-next-line no-new-func
-      factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', code);
+      factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
@@ -119,13 +121,14 @@ describe('Telmisartan Integration Test', () => {
   test('generated code produces valid AST when executed', () => {
     const ast = parse(TELMISARTAN_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     // Find the last variable name
-    const varMatch = code.match(/const (v\d+) = /g);
-    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/const (v\d+)/)[1] : 'v1';
+    const varMatch = code.match(/export const (v\d+) = /g);
+    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/export const (v\d+)/)[1] : 'v1';
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${lastVar};`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${lastVar};`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     // Note: SMILES won't match exactly due to inline ring closure limitation
@@ -141,13 +144,14 @@ describe('Telmisartan Integration Test', () => {
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(TELMISARTAN_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     // Find the last variable name
-    const varMatch = code.match(/const (v\d+) = /g);
-    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/const (v\d+)/)[1] : 'v1';
+    const varMatch = code.match(/export const (v\d+) = /g);
+    const lastVar = varMatch ? varMatch[varMatch.length - 1].match(/export const (v\d+)/)[1] : 'v1';
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${lastVar};`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${lastVar};`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     // The SMILES won't be identical but should be valid
@@ -158,11 +162,12 @@ describe('Telmisartan Integration Test', () => {
   test('simple benzimidazole codegen round-trip', () => {
     const ast = parse(BENZIMIDAZOLE_SMILES);
     const code = ast.toCode('v');
+    const executableCode = stripExports(code);
 
     expect(code).toBe(BENZIMIDAZOLE_CODE);
 
     // eslint-disable-next-line no-new-func
-    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn v5;`);
+    const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn v5;`);
     const reconstructed = factory(Ring, Linear, FusedRing, Molecule);
 
     expect(ast.smiles).toBe(BENZIMIDAZOLE_SMILES);

package/test-integration/utils.js

@@ -3,6 +3,14 @@ import {
   Ring, Linear, FusedRing, Molecule,
 } from '../src/constructors.js';
 
+/**
+ * Strip 'export ' from code for execution in new Function()
+ * (new Function doesn't support ES module syntax)
+ */
+export function stripExports(code) {
+  return code.replace(/^export /gm, '');
+}
+
 /**
  * Perform a codegen round-trip: SMILES -> AST -> CODE -> AST
  * Returns the reconstructed AST node
@@ -14,15 +22,18 @@ export function codegenRoundTrip(smiles) {
   const code = ast.toCode('v');
 
   // Find the last variable name in the generated code
-  const varMatches = code.match(/const (v\d+)/g);
+  const varMatches = code.match(/export const (v\d+)/g);
   if (!varMatches) {
     throw new Error('No variables found in generated code');
   }
-  const lastVar = varMatches[varMatches.length - 1].replace('const ', '');
+  const lastVar = varMatches[varMatches.length - 1].replace('export const ', '');
+
+  // Strip 'export ' for evaluation in new Function (not supported in non-module context)
+  const executableCode = code.replace(/^export /gm, '');
 
   // Execute the code to reconstruct the AST
   // eslint-disable-next-line no-new-func
-  const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${code}\nreturn ${lastVar};`);
+  const factory = new Function('Ring', 'Linear', 'FusedRing', 'Molecule', `${executableCode}\nreturn ${lastVar};`);
   return factory(Ring, Linear, FusedRing, Molecule);
 }