selfies-js 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "selfies-js",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Pure JavaScript SELFIES encoder/decoder with DSL for molecular composition",
   "type": "module",
   "main": "src/index.js",

package/src/decoder.js

@@ -415,10 +415,81 @@ export function deriveBranch(tokens, startIndex, maxDerive, initState, rootAtom,
     const token = tokens[startIndex + consumed]
     const content = token.slice(1, -1)
 
-    // Skip structural tokens in branch
-    if (content.includes('Branch') || content.includes('Ring') ||
-        content.includes('ch') || content.includes('ng')) {
+    // Handle Ring tokens inside branch
+    if (content.includes('Ring') || content.includes('ng')) {
+      const ringInfo = processRingSymbol(token)
+      if (!ringInfo) {
+        throw new Error(`Invalid ring token in branch: ${token}`)
+      }
+      if (state === 0) {
+        throw new Error(`Ring ${token} at invalid state 0 inside branch`)
+      }
+
+      const { order: requestedOrder, L } = ringInfo
+      const [bondOrder, nextState] = nextRingState(requestedOrder, state)
+
+      consumed++
+      derived++ // Ring counts toward derive limit
+
+      if (consumed >= tokens.length - startIndex) {
+        state = nextState
+        break
+      }
+
+      const Q = readIndexFromTokens(tokens, startIndex + consumed, L)
+      consumed += Q.consumed
+      derived += Q.consumed // Q index tokens also count
+
+      const targetIndex = Math.max(0, prevAtomIndex - (Q.value + 1))
+      if (targetIndex !== prevAtomIndex) {
+        handleRingClosure(targetIndex, prevAtomIndex, bondOrder, bonds, rings)
+      }
+
+      state = nextState
+      continue
+    }
+
+    // Handle nested Branch tokens - recursively process them
+    if (content.includes('Branch') || content.includes('ch')) {
+      const branchInfo = processBranchSymbol(token)
+      if (!branchInfo) {
+        throw new Error(`Invalid branch token in branch: ${token}`)
+      }
+      if (state <= 1) {
+        throw new Error(`Branch ${token} at invalid state ${state} inside branch`)
+      }
+
+      const { order: branchOrder, L } = branchInfo
+      const [branchInitState, nextState] = nextBranchState(branchOrder, state)
+
       consumed++
+      derived++ // Branch counts toward derive limit
+
+      if (consumed >= tokens.length - startIndex) {
+        state = nextState
+        break
+      }
+
+      // Read Q index
+      const Q = readIndexFromTokens(tokens, startIndex + consumed, L)
+      consumed += Q.consumed
+      derived += Q.consumed // Q index tokens count
+
+      // Recursively derive nested branch
+      const nestedResult = deriveBranch(
+        tokens,
+        startIndex + consumed,
+        Q.value + 1,
+        branchInitState,
+        prevAtomIndex,
+        atoms,
+        bonds,
+        rings
+      )
+      consumed += nestedResult.consumed
+      derived += nestedResult.derived
+
+      state = nextState
       continue
     }
 

package/src/dsl/valenceValidator.js

@@ -25,26 +25,10 @@ export function validateValence(selfies, defName) {
   const errors = []
 
   try {
-    // Try to decode to SMILES - this will catch many structural issues
+    // Try to decode to SMILES - this validates the structure
+    // The decoder's state machine properly enforces valence rules
     const smiles = decode(selfies)
-
-    // Parse the SELFIES to extract atoms and bonds
-    const tokens = tokenizeSelfies(selfies)
-    const atomBonds = calculateBonds(tokens)
-
-    // Check each atom's valence
-    for (const [atom, bondCount] of Object.entries(atomBonds)) {
-      const { element, charge } = parseAtom(atom)
-      const maxBonds = getBondingCapacity(element, charge)
-
-      if (bondCount > maxBonds) {
-        errors.push({
-          message: `Valence error in '${defName}': ${element} has ${bondCount} bonds but max is ${maxBonds}`,
-          severity: 'error',
-          definitionName: defName
-        })
-      }
-    }
+    // If decoding succeeds, the SELFIES is valid
   } catch (error) {
     // If decoding fails, it's a structural error
     errors.push({