smiles-js 2.0.3 → 2.2.0

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

@@ -26,6 +26,12 @@ describe('Celecoxib Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(CELECOXIB_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(CELECOXIB_SMILES);
     const code = ast.toCode('v');
@@ -33,14 +39,14 @@ describe('Celecoxib Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(CELECOXIB_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -66,6 +72,12 @@ describe('Meloxicam Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(MELOXICAM_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(MELOXICAM_SMILES);
     const code = ast.toCode('v');
@@ -73,14 +85,14 @@ describe('Meloxicam Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(MELOXICAM_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -106,6 +118,12 @@ describe('Piroxicam Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(PIROXICAM_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(PIROXICAM_SMILES);
     const code = ast.toCode('v');
@@ -113,14 +131,14 @@ describe('Piroxicam Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(PIROXICAM_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -146,6 +164,12 @@ describe('Etodolac Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(ETODOLAC_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(ETODOLAC_SMILES);
     const code = ast.toCode('v');
@@ -153,14 +177,14 @@ describe('Etodolac Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(ETODOLAC_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -186,6 +210,12 @@ describe('Ketorolac Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(KETOROLAC_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(KETOROLAC_SMILES);
     const code = ast.toCode('v');
@@ -193,14 +223,14 @@ describe('Ketorolac Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(KETOROLAC_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -227,6 +257,12 @@ describe('Rofecoxib Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(ROFECOXIB_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(ROFECOXIB_SMILES);
     const code = ast.toCode('v');
@@ -234,14 +270,14 @@ describe('Rofecoxib Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(ROFECOXIB_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -267,6 +303,12 @@ describe('Etoricoxib Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(ETORICOXIB_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(ETORICOXIB_SMILES);
     const code = ast.toCode('v');
@@ -274,14 +316,14 @@ describe('Etoricoxib Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(ETORICOXIB_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -307,6 +349,12 @@ describe('Nabumetone Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(NABUMETONE_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(NABUMETONE_SMILES);
     const code = ast.toCode('v');
@@ -314,14 +362,14 @@ describe('Nabumetone Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(NABUMETONE_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -348,6 +396,12 @@ describe('Oxaprozin Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(OXAPROZIN_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(OXAPROZIN_SMILES);
     const code = ast.toCode('v');
@@ -355,14 +409,14 @@ describe('Oxaprozin Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(OXAPROZIN_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);

package/test-integration/opioids.test.js

@@ -23,6 +23,12 @@ describe('Morphine Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(MORPHINE_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(MORPHINE_SMILES);
     const code = ast.toCode('v');
@@ -30,14 +36,14 @@ describe('Morphine Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(MORPHINE_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -63,6 +69,12 @@ describe('Codeine Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(CODEINE_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(CODEINE_SMILES);
     const code = ast.toCode('v');
@@ -70,14 +82,14 @@ describe('Codeine Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(CODEINE_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -102,6 +114,12 @@ describe('Oxycodone Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(OXYCODONE_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(OXYCODONE_SMILES);
     const code = ast.toCode('v');
@@ -109,14 +127,14 @@ describe('Oxycodone Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(OXYCODONE_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -141,6 +159,12 @@ describe('Hydrocodone Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(HYDROCODONE_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(HYDROCODONE_SMILES);
     const code = ast.toCode('v');
@@ -148,14 +172,14 @@ describe('Hydrocodone Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(HYDROCODONE_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -181,6 +205,12 @@ describe('Fentanyl Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(FENTANYL_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(FENTANYL_SMILES);
     const code = ast.toCode('v');
@@ -188,14 +218,14 @@ describe('Fentanyl Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(FENTANYL_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -221,6 +251,12 @@ describe('Tramadol Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(TRAMADOL_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(TRAMADOL_SMILES);
     const code = ast.toCode('v');
@@ -228,14 +264,14 @@ describe('Tramadol Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(TRAMADOL_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);
@@ -261,6 +297,12 @@ describe('Methadone Integration Test', () => {
     expect(code).toMatchSnapshot();
   });
 
+  test('generates valid verbose code via toCode()', () => {
+    const ast = parse(METHADONE_SMILES);
+    const code = ast.toCode('v', { verbose: true });
+    expect(code).toMatchSnapshot();
+  });
+
   test('generated code is valid JavaScript', () => {
     const ast = parse(METHADONE_SMILES);
     const code = ast.toCode('v');
@@ -268,14 +310,14 @@ describe('Methadone Integration Test', () => {
 
     let factory;
     expect(() => {
-      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', executableCode);
+      factory = createFunction('Ring', 'Linear', 'FusedRing', 'Molecule', 'RawFragment', 'Fragment', executableCode);
     }).not.toThrow();
     expect(typeof factory).toBe('function');
   });
 
   test('codegen round-trip: generated code produces valid SMILES', () => {
     const ast = parse(METHADONE_SMILES);
-    const code = ast.toCode('v');
+    const code = ast.toCode('v', { verbose: true });
     const executableCode = stripExports(code);
 
     const varMatch = code.match(/export const (v\d+) = /g);

package/test-integration/polymer.test.js

@@ -0,0 +1,148 @@
+import { describe, test, expect } from 'bun:test';
+import { Ring, Linear, Molecule } from '../src/constructors.js';
+
+describe('Polymer repeat() Integration', () => {
+  test('polyethylene trimer: -[CH2CH2]3-', () => {
+    const ethylene = Linear(['C', 'C']);
+    const pe = ethylene.repeat(3, 1, 2);
+    expect(pe.smiles).toBe('CCCCCC');
+  });
+
+  test('polystyrene dimer: styrene with phenyl pendant', () => {
+    const styrene = Linear(['C', 'C']).attach(
+      2,
+      Ring({ atoms: 'c', size: 6 }),
+    );
+    const ps = styrene.repeat(2, 1, 2);
+    expect(ps.smiles).toBe('CC(c1ccccc1)CC(c2ccccc2)');
+  });
+
+  test('polystyrene trimer', () => {
+    const styrene = Linear(['C', 'C']).attach(
+      2,
+      Ring({ atoms: 'c', size: 6 }),
+    );
+    const ps = styrene.repeat(3, 1, 2);
+    expect(ps.smiles).toBe('CC(c1ccccc1)CC(c2ccccc2)CC(c3ccccc3)');
+  });
+
+  test('poly(vinyl alcohol) dimer: -[CH2CH(OH)]2-', () => {
+    const vinylAlcohol = Linear(['C', 'C']).attach(
+      2,
+      Linear(['O']),
+    );
+    const pva = vinylAlcohol.repeat(2, 1, 2);
+    expect(pva.smiles).toBe('CC(O)CC(O)');
+  });
+
+  test('biphenyl: two linked benzene rings', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const biphenyl = benzene.repeat(2, 1, 6);
+    expect(biphenyl.smiles).toBe('c1ccccc1c2ccccc2');
+  });
+
+  test('terphenyl: three linked benzene rings', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const terphenyl = benzene.repeat(3, 1, 6);
+    expect(terphenyl.smiles).toBe('c1ccccc1c2ccccc2c3ccccc3');
+  });
+
+  test('bipyridine: two linked pyridine rings', () => {
+    const pyridine = Ring({
+      atoms: 'c',
+      size: 6,
+      substitutions: { 3: 'n' },
+    });
+    const bipyridine = pyridine.repeat(2, 1, 6);
+    expect(bipyridine.smiles).toBe('c1cnccc1c2cnccc2');
+  });
+
+  test('polyoxymethylene trimer: -[CH2O]3-', () => {
+    const oxymethylene = Linear(['C', 'O']);
+    const pom = oxymethylene.repeat(3, 1, 2);
+    expect(pom.smiles).toBe('COCOCO');
+  });
+
+  test('nylon 6,6 repeating unit dimer', () => {
+    const unit = Molecule([
+      Linear(['N', 'C'], [null, '=']),
+      Linear(['C', 'C', 'C', 'C']),
+      Linear(['C', 'N'], ['=', null]),
+      Linear(['C', 'C', 'C', 'C', 'C', 'C']),
+    ]);
+    const dimer = unit.repeat(2, 1, 1);
+    expect(dimer.type).toBe('molecule');
+    expect(dimer.components).toHaveLength(2);
+    expect(dimer.smiles).toBe('N=CCCCC=CNCCCCCCN=CCCCC=CNCCCCCC');
+  });
+});
+
+describe('Polymer fusedRepeat() Integration', () => {
+  test('naphthalene: 2 fused aromatic rings', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const naphthalene = benzene.fusedRepeat(2, 4);
+    expect(naphthalene.type).toBe('fused_ring');
+    expect(naphthalene.rings).toHaveLength(2);
+    expect(naphthalene.rings[0].ringNumber).toBe(1);
+    expect(naphthalene.rings[1].ringNumber).toBe(2);
+  });
+
+  test('anthracene: 3 fused aromatic rings', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const anthracene = benzene.fusedRepeat(3, 4);
+    expect(anthracene.type).toBe('fused_ring');
+    expect(anthracene.rings).toHaveLength(3);
+  });
+
+  test('tetracene: 4 fused aromatic rings', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const tetracene = benzene.fusedRepeat(4, 4);
+    expect(tetracene.type).toBe('fused_ring');
+    expect(tetracene.rings).toHaveLength(4);
+  });
+
+  test('fused cyclohexane dimer (decalin-like)', () => {
+    const cyclohexane = Ring({ atoms: 'C', size: 6 });
+    const decalin = cyclohexane.fusedRepeat(2, 4);
+    expect(decalin.type).toBe('fused_ring');
+    expect(decalin.rings).toHaveLength(2);
+  });
+
+  test('fused 5-membered rings (pentalene-like)', () => {
+    const cp = Ring({ atoms: 'C', size: 5 });
+    const pentalene = cp.fusedRepeat(2, 3);
+    expect(pentalene.type).toBe('fused_ring');
+    expect(pentalene.rings).toHaveLength(2);
+  });
+});
+
+describe('Polymer edge cases', () => {
+  test('repeat n=1 returns clone, not original', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const clone = benzene.repeat(1, 1, 6);
+    expect(clone.smiles).toBe('c1ccccc1');
+    expect(clone).not.toBe(benzene);
+  });
+
+  test('fusedRepeat n=1 returns ring clone', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const clone = benzene.fusedRepeat(1, 4);
+    expect(clone.smiles).toBe('c1ccccc1');
+    expect(clone.type).toBe('ring');
+    expect(clone).not.toBe(benzene);
+  });
+
+  test('large repeat count (n=10)', () => {
+    const ethylene = Linear(['C', 'C']);
+    const pe10 = ethylene.repeat(10, 1, 2);
+    expect(pe10.smiles).toBe('C'.repeat(20));
+  });
+
+  test('repeat preserves immutability of original', () => {
+    const benzene = Ring({ atoms: 'c', size: 6 });
+    const original = benzene.smiles;
+    benzene.repeat(5, 1, 6);
+    benzene.fusedRepeat(3, 4);
+    expect(benzene.smiles).toBe(original);
+  });
+});