@lokascript/framework 2.0.0 → 2.2.0

package/dist/core/pattern-matching/index.js

@@ -266,7 +266,7 @@ var _PatternMatcher = class _PatternMatcher {
    * a token and the immediately following pattern token fails, the matcher
    * resets to before the optional role and retries the failed token.
    */
-  matchTokenSequence(tokens, patternTokens, captured) {
+  matchTokenSequence(tokens, patternTokens, captured, parentStopMarkers) {
     const firstPatternToken = patternTokens[0];
     const patternExpectsConjunction = firstPatternToken?.type === "literal" && (firstPatternToken.value === "and" || firstPatternToken.value === "then" || firstPatternToken.alternatives?.includes("and") || firstPatternToken.alternatives?.includes("then"));
     if (this.currentProfile?.code === "ar" && !patternExpectsConjunction) {
@@ -290,6 +290,9 @@ var _PatternMatcher = class _PatternMatcher {
       );
       if (patternToken.type === "role" && patternToken.greedy) {
         const stopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+        if (parentStopMarkers) {
+          for (const m of parentStopMarkers) stopMarkers.add(m);
+        }
         const values = [];
         while (!tokens.isAtEnd()) {
           const nextToken = tokens.peek();
@@ -309,8 +312,58 @@ var _PatternMatcher = class _PatternMatcher {
           return false;
         }
       }
+      if (patternToken.type === "group") {
+        const siblingStopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+        if (parentStopMarkers) {
+          for (const m of parentStopMarkers) siblingStopMarkers.add(m);
+        }
+        const groupMatched = this.matchGroupToken(
+          tokens,
+          patternToken,
+          captured,
+          siblingStopMarkers
+        );
+        if (groupMatched) {
+          prevOptionalMark = null;
+          prevOptionalRole = null;
+          continue;
+        }
+        if (this.isOptional(patternToken)) {
+          continue;
+        }
+        return false;
+      }
       const isOptionalRole = patternToken.type === "role" && patternToken.optional === true;
       const markBefore = isOptionalRole ? tokens.mark() : null;
+      const isRoleToken = patternToken.type === "role";
+      if (isRoleToken && !isOptionalRole) {
+        const nextPT = i + 1 < patternTokens.length ? patternTokens[i + 1] : null;
+        if (nextPT?.type === "literal") {
+          const currentToken = tokens.peek();
+          if (currentToken && this.getMatchType(currentToken, nextPT.value) !== "none") {
+            this.logger.debug(
+              "  >> MARKER-STEAL GUARD: current token matches next literal, skipping role"
+            );
+            this.logger.debug("  >> Token match FAILED");
+            if (this.isOptional(patternToken)) {
+              continue;
+            }
+            if (prevOptionalMark && prevOptionalRole) {
+              this.logger.debug("  >> BACKTRACKING: undoing optional role", prevOptionalRole);
+              tokens.reset(prevOptionalMark);
+              captured.delete(prevOptionalRole);
+              prevOptionalMark = null;
+              prevOptionalRole = null;
+              const retryMatched = this.matchPatternToken(tokens, patternToken, captured);
+              this.logger.debug("  >> Backtrack retry result:", retryMatched);
+              if (retryMatched) {
+                continue;
+              }
+            }
+            return false;
+          }
+        }
+      }
       const matched = this.matchPatternToken(tokens, patternToken, captured);
       this.logger.debug("  >> Match result:", matched);
       if (matched) {
@@ -431,7 +484,7 @@ var _PatternMatcher = class _PatternMatcher {
     const possessiveValue = this.tryMatchPossessiveExpression(tokens);
     if (possessiveValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(possessiveValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible(possessiveValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -441,7 +494,7 @@ var _PatternMatcher = class _PatternMatcher {
     const methodCallValue = this.tryMatchMethodCallExpression(tokens);
     if (methodCallValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(methodCallValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible(methodCallValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -461,7 +514,7 @@ var _PatternMatcher = class _PatternMatcher {
     const propertyAccessValue = this.tryMatchPropertyAccessExpression(tokens);
     if (propertyAccessValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(propertyAccessValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible(propertyAccessValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -781,10 +834,15 @@ var _PatternMatcher = class _PatternMatcher {
    * (e.g., a value like 'hello') to sit between groups without blocking later
    * marker matches.
    */
-  matchGroupToken(tokens, patternToken, captured) {
+  matchGroupToken(tokens, patternToken, captured, parentStopMarkers) {
     const mark = tokens.mark();
     const capturedBefore = new Set(captured.keys());
-    const success = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+    const success = this.matchTokenSequence(
+      tokens,
+      patternToken.tokens,
+      captured,
+      parentStopMarkers
+    );
     if (success) return true;
     tokens.reset(mark);
     for (const role of captured.keys()) {
@@ -806,7 +864,12 @@ var _PatternMatcher = class _PatternMatcher {
             "- skipping intervening tokens"
           );
           for (let s = 0; s < offset; s++) tokens.advance();
-          const retrySuccess = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+          const retrySuccess = this.matchTokenSequence(
+            tokens,
+            patternToken.tokens,
+            captured,
+            parentStopMarkers
+          );
           if (retrySuccess) return true;
           tokens.reset(mark);
           for (const role of captured.keys()) {
@@ -873,7 +936,7 @@ var _PatternMatcher = class _PatternMatcher {
             break;
           }
         }
-        break;
+        if (!pt.optional) break;
       }
     }
     return markers;
@@ -883,8 +946,9 @@ var _PatternMatcher = class _PatternMatcher {
    */
   isStopMarker(token, stopMarkers) {
     if (stopMarkers.size === 0) return false;
-    const value = (token.normalized || token.value).toLowerCase();
-    return stopMarkers.has(value);
+    if (stopMarkers.has(token.value.toLowerCase())) return true;
+    if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
+    return false;
   }
   /**
    * Convert a language token to a semantic value.