smiles-js 2.1.0 → 2.2.0

package/docs/smiles.peggy

@@ -0,0 +1,215 @@
+// SMILES Grammar for Peggy (PEG parser generator for JavaScript)
+//
+// This grammar mirrors the tokenizer + buildAtomList two-pass architecture
+// in src/tokenizer.js and src/parser/smiles-parser-core.js.
+//
+// What this grammar produces:
+//   A concrete parse tree (token stream with structure). The codebase then
+//   does a second semantic pass (buildAST) to detect rings, fused rings,
+//   and attachments — that pass is stateful and cannot be expressed in PEG.
+//
+// Usage:
+//   npx peggy smiles.peggy                          # generates smiles.js
+//   npx peggy --format commonjs -o smiles.cjs smiles.peggy  # CommonJS
+//
+// Differences from OpenSMILES spec (matches codebase behavior):
+//   - Simple atoms accept ANY [A-Za-z] letter, not just the organic subset.
+//     The tokenizer (isAtomStart + parseSimpleAtom) only special-cases Br/Cl
+//     as two-letter atoms; everything else is a single letter.
+//   - Bracketed atoms capture raw content only (the codebase has a TODO for
+//     full isotope/chirality/hcount/charge/class parsing). The grammar DOES
+//     parse the sub-fields since it's trivial in PEG and useful for consumers.
+//   - Whitespace is silently skipped (tokenizer.js line 104).
+//   - Ring markers can be preceded by a bond (e.g. C=1CC=1 is legal SMILES).
+
+// ============================================================
+// Top-level: dot-separated components
+// Mirrors: tokenizer DOT token → buildAtomList skips DOT
+// ============================================================
+smiles
+  = _ head:chain tail:(_ "." _ chain)* _ {
+      const components = [head, ...tail.map(t => t[3])];
+      if (components.length === 1) return components[0];
+      return { type: "molecule", components };
+    }
+
+// ============================================================
+// Chain: sequence of atom_units with optional bonds between them
+// Mirrors: buildAtomList's linear scan — each ATOM token may be
+//          preceded by a BOND token, and followed by RING_MARKER
+//          and BRANCH_OPEN/CLOSE tokens.
+// ============================================================
+chain
+  = first:atom_unit rest:(_ bond? _ atom_unit)* {
+      const atoms = [first];
+      const bonds = [null];
+      for (const r of rest) {
+        bonds.push(r[1]);
+        atoms.push(r[3]);
+      }
+      return { type: "chain", atoms, bonds };
+    }
+
+// ============================================================
+// Atom unit: atom + ring markers + branches
+//
+// Mirrors the token consumption order in buildAtomList:
+//   ATOM → RING_MARKER* → (BRANCH_OPEN chain BRANCH_CLOSE)*
+//
+// Ring markers can carry their own bond (e.g. C=1...=1)
+// This is valid SMILES: the bond on a ring closure describes
+// the bond between the two ring-closure atoms.
+// ============================================================
+atom_unit
+  = atom:atom ring_bonds:(bond? ring_marker)* branches:branch* {
+      const rings = ring_bonds.map(rb => ({
+        bond: rb[0],
+        number: rb[1]
+      }));
+      return { atom, rings, branches };
+    }
+
+// ============================================================
+// Atoms
+//
+// Two forms, matching tokenizer.js:
+//   1. Bracketed: '[' ... ']'  (parseBracketedAtom, line 67)
+//   2. Simple: [A-Za-z*]       (parseSimpleAtom, line 39)
+// ============================================================
+atom
+  = bracketed_atom
+  / simple_atom
+
+// ----------------------------------------------------------
+// Bracketed atom: [isotope? element chirality? hcount? charge? class?]
+//
+// The codebase currently stores only { raw } (parseBracketedAtom, line 79).
+// We parse the sub-fields here since PEG makes it easy and consumers
+// can use them. The `raw` field preserves the full bracket text for
+// round-trip fidelity (matching token.value in the codebase).
+// ----------------------------------------------------------
+bracketed_atom
+  = "[" content:bracketed_content "]" {
+      return { type: "bracket_atom", ...content, raw: text() };
+    }
+
+bracketed_content
+  = isotope:isotope?
+    symbol:bracket_element
+    chirality:chirality?
+    hcount:hcount?
+    charge:charge?
+    atomClass:atom_class? {
+      return { isotope, symbol, chirality, hcount, charge, atomClass };
+    }
+
+// Isotope: digits before the element symbol
+// e.g. [13C], [2H]
+isotope
+  = digits:$[0-9]+ &[A-Za-z*] { return parseInt(digits, 10); }
+
+// Element inside brackets — can be aromatic two-letter (se, as),
+// aromatic single-letter, or any standard element symbol, or wildcard
+bracket_element
+  = aromatic_element
+  / element_symbol
+  / "*" { return "*"; }
+
+// Standard element symbol: uppercase letter + optional lowercase
+// e.g. C, Na, Fe, Zr
+element_symbol
+  = a:$[A-Z] b:$[a-z]? { return b ? a + b : a; }
+
+// Aromatic elements inside brackets
+// OpenSMILES: b, c, n, o, p, s, se, as
+aromatic_element
+  = "se" { return "se"; }
+  / "as" { return "as"; }
+  / c:[bcnops] { return c; }
+
+// Chirality: @ or @@ (the codebase doesn't parse extended forms like @TH1)
+chirality
+  = "@@" { return "@@"; }
+  / "@" { return "@"; }
+
+// Hydrogen count: H or H<digit>
+// e.g. [NH3+] has hcount=3, [C@H] has hcount=1
+hcount
+  = "H" n:$[0-9]? { return n ? parseInt(n, 10) : 1; }
+
+// Charge: +, -, +2, -1, ++, --
+// Ordered to try multi-char patterns before single-char
+charge
+  = "++" { return 2; }
+  / "--" { return -2; }
+  / "+" n:$[0-9]+ { return parseInt(n, 10); }
+  / "-" n:$[0-9]+ { return -parseInt(n, 10); }
+  / "+" { return 1; }
+  / "-" { return -1; }
+
+// Atom class: :<digits>
+// e.g. [C:1]
+atom_class
+  = ":" n:$[0-9]+ { return parseInt(n, 10); }
+
+// ----------------------------------------------------------
+// Simple (non-bracketed) atom
+//
+// Mirrors tokenizer.js parseSimpleAtom (line 39) + isAtomStart (line 31):
+//   isAtomStart accepts /[A-Za-z*]/
+//   parseSimpleAtom checks for two-letter Cl/Br first, then single char
+//
+// The codebase does NOT restrict to the OpenSMILES organic subset —
+// it accepts any letter as a valid atom. This is intentional for
+// permissive parsing. The semantic layer validates later.
+// ----------------------------------------------------------
+simple_atom
+  = symbol:simple_atom_symbol { return { type: "simple_atom", symbol }; }
+
+simple_atom_symbol
+  = "Br" { return "Br"; }
+  / "Cl" { return "Cl"; }
+  / c:[A-Za-z] { return c; }
+  / "*" { return "*"; }
+
+// ============================================================
+// Bonds
+//
+// Mirrors: BOND_SYMBOLS in tokenizer.js (line 19)
+//   new Set(['-', '=', '#', ':', '/', '\\'])
+// ============================================================
+bond
+  = b:[-=#:/\\] { return b; }
+
+// ============================================================
+// Ring markers
+//
+// Mirrors: tokenizer.js lines 138-160
+//   '%' + two digits → ring number 10-99
+//   single digit     → ring number 0-9
+// ============================================================
+ring_marker
+  = "%" d1:[0-9] d2:[0-9] { return parseInt(d1 + d2, 10); }
+  / d:[0-9] { return parseInt(d, 10); }
+
+// ============================================================
+// Branches (recursive)
+//
+// Mirrors: BRANCH_OPEN → (bond? chain) → BRANCH_CLOSE
+// in tokenizer.js lines 106-120 and buildAtomList lines 139-153
+//
+// A branch can start with a bond that applies to the first atom
+// of the branch chain (e.g. C(=O) means double bond to O).
+// ============================================================
+branch
+  = "(" _ b:bond? _ c:chain _ ")" {
+      return { type: "branch", bond: b, chain: c };
+    }
+
+// ============================================================
+// Whitespace (optional, skipped)
+//
+// Mirrors: tokenizer.js line 104 — /\s/ is skipped
+// ============================================================
+_ "whitespace"
+  = [ \t\n\r]*

package/package.json

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

package/src/decompiler.js

@@ -9,11 +9,13 @@ import {
   isRingNode,
   isLinearNode,
 } from './ast.js';
+import { buildSMILES } from './codegen/index.js';
+import { createRingNode } from './node-creators.js';
 
 // Helper to call decompileNode (satisfies no-loop-func rule)
-function decompileChildNode(node, indent, nextVar) {
+function decompileChildNode(node, indent, nextVar, verbose) {
   // eslint-disable-next-line no-use-before-define
-  return decompileNode(node, indent, nextVar);
+  return decompileNode(node, indent, nextVar, verbose);
 }
 
 /**
@@ -110,7 +112,7 @@ function generateSubstitutionCode(ring, indent, nextVar, initialVar) {
  * Generate code for ring attachments
  * @returns {{ lines: string[], currentVar: string }}
  */
-function generateAttachmentCode(ring, indent, nextVar, initialVar) {
+function generateAttachmentCode(ring, indent, nextVar, initialVar, verbose = true) {
   const lines = [];
   let currentVar = initialVar;
 
@@ -128,7 +130,7 @@ function generateAttachmentCode(ring, indent, nextVar, initialVar) {
       const inlineBranchId = hasInlineBranchAfter ? (metaBranchIds[nextIdx] || Infinity) : Infinity;
 
       attachmentList.forEach((attachment) => {
-        const attachResult = decompileChildNode(attachment, indent, nextVar);
+        const attachResult = decompileChildNode(attachment, indent, nextVar, verbose);
         lines.push(attachResult.code);
 
         const newVar = nextVar();
@@ -158,13 +160,72 @@ function generateAttachmentCode(ring, indent, nextVar, initialVar) {
   return { lines, currentVar };
 }
 
+/**
+ * Compute the SMILES for a ring node with substitutions but without attachments.
+ * Used in non-verbose mode to emit Fragment('SMILES') for the substituted ring.
+ */
+function getRingWithSubsSmiles(ring) {
+  const tempNode = createRingNode(
+    ring.atoms,
+    ring.size,
+    ring.ringNumber,
+    ring.offset,
+    ring.substitutions,
+    {},
+    ring.bonds,
+    ring.metaBranchDepths,
+  );
+  if (ring.metaLeadingBond) {
+    tempNode.metaLeadingBond = ring.metaLeadingBond;
+  }
+  return buildSMILES(tempNode);
+}
+
 /**
  * Decompile a Ring node
  */
-function decompileRing(ring, indent, nextVar) {
+function decompileRing(ring, indent, nextVar, verbose = true) {
   const lines = [];
   const varName = nextVar();
 
+  if (!verbose && !ring.metaLeadingBond) {
+    // Non-verbose: emit Fragment('SMILES') for base ring
+    const baseSmiles = buildSMILES(createRingNode(
+      ring.atoms,
+      ring.size,
+      ring.ringNumber,
+      ring.offset,
+      {},
+      {},
+      ring.bonds,
+      ring.metaBranchDepths,
+    ));
+    lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+    // Substitutions: each becomes an independent Fragment('SMILES')
+    let currentVar = varName;
+    if (Object.keys(ring.substitutions).length > 0) {
+      const subsSmiles = getRingWithSubsSmiles(ring);
+      const newVar = nextVar();
+      lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+      currentVar = newVar;
+    }
+
+    // Attachments stay as .attach() calls
+    const { lines: attLines, currentVar: attVar } = generateAttachmentCode(
+      ring,
+      indent,
+      nextVar,
+      currentVar,
+      verbose,
+    );
+    lines.push(...attLines);
+    currentVar = attVar;
+
+    return { code: lines.join('\n'), finalVar: currentVar };
+  }
+
+  // Verbose mode (original behavior)
   // Build options object (include branchDepths for full decompilation)
   const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
   lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
@@ -185,6 +246,7 @@ function decompileRing(ring, indent, nextVar) {
     indent,
     nextVar,
     currentVar,
+    verbose,
   );
   lines.push(...attLines);
   currentVar = attVar;
@@ -195,7 +257,7 @@ function decompileRing(ring, indent, nextVar) {
 /**
  * Decompile a Linear node
  */
-function decompileLinear(linear, indent, nextVar) {
+function decompileLinear(linear, indent, nextVar, verbose = true) {
   const lines = [];
   const varName = nextVar();
 
@@ -205,7 +267,13 @@ function decompileLinear(linear, indent, nextVar) {
   const hasNonNullBonds = linear.bonds.some((b) => b !== null);
   const hasLeadingBond = linear.metaLeadingBond !== undefined;
 
-  if (hasNonNullBonds && hasLeadingBond) {
+  // Non-verbose: use Fragment('SMILES') when possible (no bonds, no leadingBond)
+  if (!verbose && !hasNonNullBonds && !hasLeadingBond) {
+    // Compute SMILES without attachments for the base linear node
+    const baseLinear = { ...linear, attachments: {} };
+    const smiles = buildSMILES(baseLinear);
+    lines.push(`${indent}const ${varName} = Fragment('${smiles}');`);
+  } else if (hasNonNullBonds && hasLeadingBond) {
     lines.push(`${indent}const ${varName} = Linear([${atomsStr}], [${formatBondsArray(linear.bonds)}], {}, '${linear.metaLeadingBond}');`);
   } else if (hasNonNullBonds) {
     lines.push(`${indent}const ${varName} = Linear([${atomsStr}], [${formatBondsArray(linear.bonds)}]);`);
@@ -222,7 +290,7 @@ function decompileLinear(linear, indent, nextVar) {
     Object.entries(linear.attachments).forEach(([pos, attachmentList]) => {
       attachmentList.forEach((attachment) => {
         // eslint-disable-next-line no-use-before-define
-        const attachRes = decompileNode(attachment, indent, nextVar);
+        const attachRes = decompileNode(attachment, indent, nextVar, verbose);
         const { code: aCode, finalVar: aFinalVar } = attachRes;
         lines.push(aCode);
 
@@ -423,7 +491,7 @@ function computeSharedPositions(fusedRing) {
  * Emits .fuse() for the first pair and .addRing() for subsequent rings.
  * The resulting code goes through the simple codegen path (offset-based).
  */
-function decompileSimpleFusedRing(fusedRing, indent, nextVar) {
+function decompileSimpleFusedRing(fusedRing, indent, nextVar, verbose = true) {
   const lines = [];
   const ringFinalVars = [];
 
@@ -486,20 +554,52 @@ function decompileSimpleFusedRing(fusedRing, indent, nextVar) {
     }
 
     const varName = nextVar();
-    const { optionsStr } = buildRingOptions(effectiveRing, { includeBranchDepths: true });
-    lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-    const {
-      lines: subLines, currentVar: subVar,
-    } = generateSubstitutionCode(effectiveRing, indent, nextVar, varName);
-    lines.push(...subLines);
+    if (!verbose && !effectiveRing.metaLeadingBond) {
+      // Non-verbose: use Fragment for ring constructor
+      const baseSmiles = buildSMILES(createRingNode(
+        effectiveRing.atoms,
+        effectiveRing.size,
+        effectiveRing.ringNumber,
+        effectiveRing.offset,
+        {},
+        {},
+        effectiveRing.bonds,
+        effectiveRing.metaBranchDepths,
+      ));
+      lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+      let currentVar = varName;
+      if (Object.keys(effectiveRing.substitutions || {}).length > 0) {
+        const subsSmiles = getRingWithSubsSmiles(effectiveRing);
+        const newVar = nextVar();
+        lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+        currentVar = newVar;
+      }
 
-    const {
-      lines: attLines, currentVar: attVar,
-    } = generateAttachmentCode(effectiveRing, indent, nextVar, subVar);
-    lines.push(...attLines);
+      const {
+        lines: attLines, currentVar: attVar,
+      } = generateAttachmentCode(effectiveRing, indent, nextVar, currentVar, verbose);
+      lines.push(...attLines);
 
-    ringFinalVars.push(attVar);
+      ringFinalVars.push(attVar);
+    } else {
+      // Verbose: original behavior
+      const { optionsStr } = buildRingOptions(effectiveRing, { includeBranchDepths: true });
+      lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
+
+      const {
+        lines: subLines, currentVar: subVar,
+      } = generateSubstitutionCode(effectiveRing, indent, nextVar, varName);
+      lines.push(...subLines);
+
+      const {
+        lines: attLines, currentVar: attVar,
+      } = generateAttachmentCode(effectiveRing, indent, nextVar, subVar, verbose);
+      lines.push(...attLines);
+
+      ringFinalVars.push(attVar);
+    }
   });
 
   const leadingBond = fusedRing.metaLeadingBond;
@@ -541,7 +641,7 @@ function decompileSimpleFusedRing(fusedRing, indent, nextVar) {
  * rings to a fused ring. The codegen uses this metadata to correctly interleave
  * ring markers and handle branch depths.
  */
-function decompileComplexFusedRing(fusedRing, indent, nextVar) {
+function decompileComplexFusedRing(fusedRing, indent, nextVar, verbose = true) {
   const lines = [];
   const sequentialRings = fusedRing.metaSequentialRings || [];
   const seqAtomAttachments = fusedRing.metaSeqAtomAttachments || new Map();
@@ -549,17 +649,45 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
   // Step 1: Decompile the base fused ring
   const ringVars = [];
   fusedRing.rings.forEach((ring) => {
-    const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
     const varName = nextVar();
-    lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-    const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
-    lines.push(...subResult.lines);
+    if (!verbose && !ring.metaLeadingBond) {
+      const baseSmiles = buildSMILES(createRingNode(
+        ring.atoms,
+        ring.size,
+        ring.ringNumber,
+        ring.offset,
+        {},
+        {},
+        ring.bonds,
+        ring.metaBranchDepths,
+      ));
+      lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+      let currentVar = varName;
+      if (Object.keys(ring.substitutions || {}).length > 0) {
+        const subsSmiles = getRingWithSubsSmiles(ring);
+        const newVar = nextVar();
+        lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+        currentVar = newVar;
+      }
 
-    const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar);
-    lines.push(...attResult.lines);
+      const attResult = generateAttachmentCode(ring, indent, nextVar, currentVar, verbose);
+      lines.push(...attResult.lines);
+
+      ringVars.push({ var: attResult.currentVar, ring });
+    } else {
+      const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
+      lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
+
+      const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
+      lines.push(...subResult.lines);
+
+      const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar, verbose);
+      lines.push(...attResult.lines);
 
-    ringVars.push({ var: attResult.currentVar, ring });
+      ringVars.push({ var: attResult.currentVar, ring });
+    }
   });
 
   // Decompile seqAtomAttachments BEFORE fuse so their vars are declared early
@@ -569,7 +697,7 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
     seqAtomAttachments.forEach((attachments, pos) => {
       const attVars = [];
       attachments.forEach((att) => {
-        const attResult = decompileChildNode(att, indent, nextVar);
+        const attResult = decompileChildNode(att, indent, nextVar, verbose);
         lines.push(attResult.code);
         attVars.push(attResult.finalVar);
       });
@@ -691,17 +819,45 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
     // Decompile sequential rings
     const seqRingVars = [];
     sequentialRings.forEach((ring) => {
-      const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
       const varName = nextVar();
-      lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-      const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
-      lines.push(...subResult.lines);
+      if (!verbose && !ring.metaLeadingBond) {
+        const baseSmiles = buildSMILES(createRingNode(
+          ring.atoms,
+          ring.size,
+          ring.ringNumber,
+          ring.offset,
+          {},
+          {},
+          ring.bonds,
+          ring.metaBranchDepths,
+        ));
+        lines.push(`${indent}const ${varName} = Fragment('${baseSmiles}');`);
+
+        let currentVar = varName;
+        if (Object.keys(ring.substitutions || {}).length > 0) {
+          const subsSmiles = getRingWithSubsSmiles(ring);
+          const newVar = nextVar();
+          lines.push(`${indent}const ${newVar} = Fragment('${subsSmiles}');`);
+          currentVar = newVar;
+        }
 
-      const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar);
-      lines.push(...attResult.lines);
+        const attResult = generateAttachmentCode(ring, indent, nextVar, currentVar, verbose);
+        lines.push(...attResult.lines);
+
+        seqRingVars.push(attResult.currentVar);
+      } else {
+        const { optionsStr } = buildRingOptions(ring, { includeBranchDepths: true });
+        lines.push(`${indent}const ${varName} = Ring({ ${optionsStr} });`);
 
-      seqRingVars.push(attResult.currentVar);
+        const subResult = generateSubstitutionCode(ring, indent, nextVar, varName);
+        lines.push(...subResult.lines);
+
+        const attResult = generateAttachmentCode(ring, indent, nextVar, subResult.currentVar, verbose);
+        lines.push(...attResult.lines);
+
+        seqRingVars.push(attResult.currentVar);
+      }
     });
 
     // Decompile chain atom attachments
@@ -710,7 +866,7 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
         const attachments = seqAtomAttachments.get(entry.attachmentPos) || [];
         const attVars = [];
         attachments.forEach((att) => {
-          const attResult = decompileChildNode(att, indent, nextVar);
+          const attResult = decompileChildNode(att, indent, nextVar, verbose);
           lines.push(attResult.code);
           attVars.push(attResult.finalVar);
         });
@@ -845,24 +1001,24 @@ function decompileComplexFusedRing(fusedRing, indent, nextVar) {
  * - Sequential rings or interleaved codegen → preserves metadata (needs it for correct SMILES)
  * - Everything else → structural API calls only (no metadata)
  */
-function decompileFusedRing(fusedRing, indent, nextVar) {
+function decompileFusedRing(fusedRing, indent, nextVar, verbose = true) {
   const seqRings = fusedRing.metaSequentialRings;
   const hasSeqRings = seqRings && seqRings.length > 0;
   const isInterleaved = needsInterleavedCodegen(fusedRing);
 
   // Use complex decompilation for sequential rings or genuinely interleaved fused rings
   if (hasSeqRings || isInterleaved) {
-    return decompileComplexFusedRing(fusedRing, indent, nextVar);
+    return decompileComplexFusedRing(fusedRing, indent, nextVar, verbose);
   }
 
   // Everything else goes through the simple path (no metadata)
-  return decompileSimpleFusedRing(fusedRing, indent, nextVar);
+  return decompileSimpleFusedRing(fusedRing, indent, nextVar, verbose);
 }
 
 /**
  * Decompile a Molecule node
  */
-function decompileMolecule(molecule, indent, nextVar) {
+function decompileMolecule(molecule, indent, nextVar, verbose = true) {
   const lines = [];
   const { components } = molecule;
 
@@ -878,7 +1034,7 @@ function decompileMolecule(molecule, indent, nextVar) {
   const componentFinalVars = [];
   components.forEach((component) => {
     // eslint-disable-next-line no-use-before-define
-    const { code: componentCode, finalVar } = decompileNode(component, indent, nextVar);
+    const { code: componentCode, finalVar } = decompileNode(component, indent, nextVar, verbose);
     lines.push(componentCode);
     // Note: metaLeadingBond is now handled in component constructors via metadata
     // or leadingBond option, so no mutation needed here
@@ -893,21 +1049,21 @@ function decompileMolecule(molecule, indent, nextVar) {
   return { code: lines.join('\n'), finalVar: finalVarName };
 }
 
-function decompileNode(node, indent, nextVar) {
+function decompileNode(node, indent, nextVar, verbose = true) {
   if (isRingNode(node)) {
-    return decompileRing(node, indent, nextVar);
+    return decompileRing(node, indent, nextVar, verbose);
   }
 
   if (isLinearNode(node)) {
-    return decompileLinear(node, indent, nextVar);
+    return decompileLinear(node, indent, nextVar, verbose);
   }
 
   if (isFusedRingNode(node)) {
-    return decompileFusedRing(node, indent, nextVar);
+    return decompileFusedRing(node, indent, nextVar, verbose);
   }
 
   if (isMoleculeNode(node)) {
-    return decompileMolecule(node, indent, nextVar);
+    return decompileMolecule(node, indent, nextVar, verbose);
   }
 
   throw new Error(`Unknown node type: ${node.type}`);
@@ -919,15 +1075,19 @@ function decompileNode(node, indent, nextVar) {
  * @param {Object} options - Options
  * @param {number} options.indent - Indentation level (default 0)
  * @param {string} options.varName - Variable name prefix (default 'v')
+ * @param {boolean} options.verbose - Use verbose constructor syntax (default false).
+ *   When false, uses Fragment('SMILES') for Ring and simple Linear nodes.
  * @param {boolean} options.includeMetadata - Include metadata assignments
  *   (default true). Set to false for cleaner output (but code may not work)
  */
 export function decompile(node, options = {}) {
-  const { indent = 0, varName = 'v', includeMetadata = true } = options;
+  const {
+    indent = 0, varName = 'v', includeMetadata = true, verbose = false,
+  } = options;
   const indentStr = '  '.repeat(indent);
   const nextVar = createCounter(varName);
 
-  const { code } = decompileNode(node, indentStr, nextVar);
+  const { code } = decompileNode(node, indentStr, nextVar, verbose);
 
   // Always use export for declarations
   let result = code.replace(/^(\s*)(const|let) /gm, '$1export $2 ');