@lokascript/framework 4.5.0 → 4.7.0

package/dist/parsing/index.js

@@ -1,24 +1,3 @@
-// src/core/types.ts
-import {
-  createLiteral,
-  createSelector,
-  createReference,
-  createPropertyPath,
-  createExpression,
-  createFlag,
-  createCommandNode,
-  createEventHandlerNode,
-  createConditionalNode,
-  createCompoundNode,
-  createLoopNode,
-  createTryNode,
-  createAsyncNode,
-  createMatchNode,
-  extractValue,
-  extractRoleValue,
-  getRoleValue
-} from "@lokascript/intent";
-
 // src/core/logger.ts
 var DebugLogger = class {
   constructor(namespace) {
@@ -86,6 +65,27 @@ function createLogger(namespace) {
   return new DebugLogger(namespace);
 }
 
+// src/core/types.ts
+import {
+  createLiteral,
+  createSelector,
+  createReference,
+  createPropertyPath,
+  createExpression,
+  createFlag,
+  createCommandNode,
+  createEventHandlerNode,
+  createConditionalNode,
+  createCompoundNode,
+  createLoopNode,
+  createTryNode,
+  createAsyncNode,
+  createMatchNode,
+  extractValue,
+  extractRoleValue,
+  getRoleValue
+} from "@lokascript/intent";
+
 // src/core/pattern-matching/utils/type-validation.ts
 function isTypeCompatible(actualType, expectedTypes) {
   if (!expectedTypes || expectedTypes.length === 0) {
@@ -108,10 +108,535 @@ function getPossessiveReference(profile, keyword) {
   return profile?.possessive?.keywords?.[keyword];
 }
 
-// src/core/pattern-matching/pattern-matcher.ts
+// src/core/matching/stock-reading.ts
 function isValidReference(_value) {
   return false;
 }
+function safeToLowerCase(value) {
+  if (typeof value === "string") {
+    return value.toLowerCase();
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return String(value).toLowerCase();
+}
+function readRoleValue(tokens, patternToken, captured, profile) {
+  skipNoiseWords(tokens);
+  const token = tokens.peek();
+  if (!token) {
+    return patternToken.optional || false;
+  }
+  const possessiveValue = tryMatchPossessiveExpression(tokens, profile);
+  if (possessiveValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(possessiveValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, possessiveValue);
+    return true;
+  }
+  const methodCallValue = tryMatchMethodCallExpression(tokens);
+  if (methodCallValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(methodCallValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, methodCallValue);
+    return true;
+  }
+  const possessiveSelectorValue = tryMatchPossessiveSelectorExpression(tokens);
+  if (possessiveSelectorValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(possessiveSelectorValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, possessiveSelectorValue);
+    return true;
+  }
+  const propertyAccessValue = tryMatchPropertyAccessExpression(tokens);
+  if (propertyAccessValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(propertyAccessValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, propertyAccessValue);
+    return true;
+  }
+  const selectorPropertyValue = tryMatchSelectorPropertyExpression(tokens);
+  if (selectorPropertyValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(selectorPropertyValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, selectorPropertyValue);
+    return true;
+  }
+  const value = tokenToSemanticValue(token);
+  if (!value) {
+    return patternToken.optional || false;
+  }
+  if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+    if (!isTypeCompatible(value.type, patternToken.expectedTypes)) {
+      return patternToken.optional || false;
+    }
+  }
+  captured.set(patternToken.role, value);
+  tokens.advance();
+  return true;
+}
+function tryMatchPossessiveExpression(tokens, profile) {
+  const token = tokens.peek();
+  if (!token) return null;
+  if (!profile) return null;
+  const tokenValue = token.normalized || token.value;
+  const tokenLower = safeToLowerCase(tokenValue);
+  const baseRef = getPossessiveReference(profile, tokenLower);
+  if (!baseRef) return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken) {
+    tokens.reset(mark);
+    return null;
+  }
+  if (propertyToken.kind === "identifier" || propertyToken.kind === "keyword" && !isStructuralKeyword(propertyToken.value) || propertyToken.kind === "selector" && propertyToken.value.startsWith("*") || propertyToken.kind === "selector" && propertyToken.value.startsWith("@") || propertyToken.kind === "selector" && propertyToken.value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyToken.value)) {
+    tokens.advance();
+    let propertyName = propertyToken.value;
+    if (propertyToken.kind === "selector" && propertyName.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyName)) {
+      propertyName = propertyName.substring(1);
+    }
+    let chainedProps = propertyName;
+    while (tokens.peek()?.kind === "selector" && tokens.peek().value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(tokens.peek().value)) {
+      chainedProps += tokens.peek().value;
+      tokens.advance();
+    }
+    const nextPeek = tokens.peek();
+    if (nextPeek?.kind === "literal" && nextPeek.value.startsWith("(")) {
+      chainedProps += nextPeek.value;
+      tokens.advance();
+    }
+    return createPropertyPath(createReference(baseRef), chainedProps);
+  }
+  tokens.reset(mark);
+  return null;
+}
+function isStructuralKeyword(value) {
+  const structural = /* @__PURE__ */ new Set([
+    // Prepositions
+    "into",
+    "in",
+    "to",
+    "from",
+    "at",
+    "by",
+    "with",
+    "without",
+    "before",
+    "after",
+    "of",
+    "as",
+    "on",
+    // Control flow
+    "then",
+    "end",
+    "else",
+    "if",
+    "repeat",
+    "while",
+    "for",
+    // Commands (shouldn't be property names)
+    "toggle",
+    "add",
+    "remove",
+    "put",
+    "set",
+    "show",
+    "hide",
+    "increment",
+    "decrement",
+    "send",
+    "trigger",
+    "call"
+  ]);
+  return structural.has(value.toLowerCase());
+}
+function tryMatchMethodCallExpression(tokens) {
+  const token = tokens.peek();
+  if (!token || token.kind !== "selector") return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const dotToken = tokens.peek();
+  if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const methodToken = tokens.peek();
+  if (!methodToken || methodToken.kind !== "identifier") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const openParen = tokens.peek();
+  if (!openParen || openParen.kind !== "punctuation" || openParen.value !== "(") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const args = [];
+  while (!tokens.isAtEnd() && args.length < MAX_METHOD_ARGS) {
+    const argToken = tokens.peek();
+    if (!argToken) break;
+    if (argToken.kind === "punctuation" && argToken.value === ")") {
+      tokens.advance();
+      break;
+    }
+    if (argToken.kind === "punctuation" && argToken.value === ",") {
+      tokens.advance();
+      continue;
+    }
+    args.push(argToken.value);
+    tokens.advance();
+  }
+  const methodCall = `${token.value}.${methodToken.value}(${args.join(", ")})`;
+  return {
+    type: "expression",
+    raw: methodCall
+  };
+}
+function tryMatchPropertyAccessExpression(tokens) {
+  const token = tokens.peek();
+  if (!token) return null;
+  if (token.kind !== "identifier" && token.kind !== "keyword") return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const dotToken = tokens.peek();
+  if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken || propertyToken.kind !== "identifier") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  let chain = `${token.value}.${propertyToken.value}`;
+  let depth = 1;
+  while (!tokens.isAtEnd() && depth < MAX_PROPERTY_DEPTH) {
+    const nextDot = tokens.peek();
+    if (!nextDot || nextDot.kind !== "operator" || nextDot.value !== ".") {
+      break;
+    }
+    tokens.advance();
+    const nextProp = tokens.peek();
+    if (!nextProp || nextProp.kind !== "identifier") {
+      break;
+    }
+    tokens.advance();
+    chain += `.${nextProp.value}`;
+    depth++;
+  }
+  const openParen = tokens.peek();
+  if (openParen && openParen.kind === "punctuation" && openParen.value === "(") {
+    tokens.advance();
+    const args = [];
+    let argDepth = 0;
+    while (!tokens.isAtEnd() && args.length < MAX_METHOD_ARGS) {
+      const argToken = tokens.peek();
+      if (!argToken) break;
+      if (argToken.kind === "punctuation" && argToken.value === ")") {
+        if (argDepth === 0) {
+          tokens.advance();
+          break;
+        }
+        argDepth--;
+      }
+      if (argToken.kind === "punctuation" && argToken.value === "(") {
+        argDepth++;
+      }
+      if (argToken.kind === "punctuation" && argToken.value === ",") {
+        tokens.advance();
+        continue;
+      }
+      args.push(argToken.value);
+      tokens.advance();
+    }
+    const methodCall = `${chain}(${args.join(", ")})`;
+    return {
+      type: "expression",
+      raw: methodCall
+    };
+  }
+  return {
+    type: "expression",
+    raw: chain
+  };
+}
+function tryMatchPossessiveSelectorExpression(tokens) {
+  const token = tokens.peek();
+  if (!token || token.kind !== "selector") return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const possessiveToken = tokens.peek();
+  if (!possessiveToken || possessiveToken.kind !== "punctuation" || possessiveToken.value !== "'s") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken) {
+    tokens.reset(mark);
+    return null;
+  }
+  if (propertyToken.kind !== "selector" && propertyToken.kind !== "identifier") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  return createPropertyPath(createSelector(token.value), propertyToken.value);
+}
+function tryMatchSelectorPropertyExpression(tokens) {
+  const token = tokens.peek();
+  if (!token || token.kind !== "selector") return null;
+  if (typeof token.value !== "string" || !token.value.startsWith("#")) return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken || propertyToken.kind !== "selector") {
+    tokens.reset(mark);
+    return null;
+  }
+  if (!propertyToken.value.startsWith(".")) {
+    tokens.reset(mark);
+    return null;
+  }
+  const peek2 = tokens.peek(1);
+  if (peek2 && peek2.kind === "selector") {
+  }
+  tokens.advance();
+  const propertyName = propertyToken.value.slice(1);
+  return createPropertyPath(createSelector(token.value), propertyName);
+}
+var MAX_PROPERTY_DEPTH = 10;
+var MAX_METHOD_ARGS = 20;
+function tokenToSemanticValue(token) {
+  switch (token.kind) {
+    case "selector":
+      return createSelector(token.value);
+    case "literal":
+      return parseLiteralValue(token.value);
+    case "keyword": {
+      const tokenValue = token.normalized || token.value;
+      const lower = safeToLowerCase(tokenValue);
+      if (isValidReference(lower)) {
+        return createReference(lower);
+      }
+      return createLiteral(token.normalized || token.value);
+    }
+    case "identifier": {
+      if (typeof token.value === "string" && token.value.startsWith(":")) {
+        return createReference(token.value);
+      }
+      const identLower = safeToLowerCase(token.value);
+      if (isValidReference(identLower)) {
+        return createReference(identLower);
+      }
+      return { type: "expression", raw: token.value };
+    }
+    case "url":
+      return createLiteral(token.value, "string");
+    default:
+      return null;
+  }
+}
+function parseLiteralValue(value) {
+  if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
+    const inner = value.slice(1, -1);
+    return createLiteral(inner, "string");
+  }
+  if (value === "true") return createLiteral(true, "boolean");
+  if (value === "false") return createLiteral(false, "boolean");
+  const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (durationMatch) {
+    const num2 = parseFloat(durationMatch[1]);
+    const unit = durationMatch[2];
+    if (unit) {
+      return createLiteral(value, "duration");
+    }
+    return createLiteral(num2, "number");
+  }
+  const num = parseFloat(value);
+  if (!isNaN(num)) {
+    return createLiteral(num, "number");
+  }
+  return createLiteral(value, "string");
+}
+var ENGLISH_NOISE_WORDS = /* @__PURE__ */ new Set(["the", "a", "an"]);
+function skipNoiseWords(tokens) {
+  const token = tokens.peek();
+  if (!token) return;
+  const tokenLower = safeToLowerCase(token.value);
+  if (ENGLISH_NOISE_WORDS.has(tokenLower)) {
+    const mark = tokens.mark();
+    tokens.advance();
+    const nextToken = tokens.peek();
+    if (nextToken && nextToken.kind === "selector") {
+      return;
+    }
+    tokens.reset(mark);
+  }
+  if (tokenLower === "class") {
+    tokens.advance();
+  }
+}
+
+// src/core/matching/stock-confidence.ts
+function scoreParts(ctx) {
+  const { pattern, captured } = ctx;
+  let score = 0;
+  let maxScore = 0;
+  const hasDefault = (role) => {
+    return pattern.extraction?.[role]?.default !== void 0;
+  };
+  for (const token of pattern.template.tokens) {
+    if (token.type === "role") {
+      maxScore += 1;
+      if (captured.has(token.role)) {
+        score += 1;
+      }
+    } else if (token.type === "group") {
+      for (const subToken of token.tokens) {
+        if (subToken.type === "role") {
+          const roleHasDefault = hasDefault(subToken.role);
+          const weight = 0.8;
+          maxScore += weight;
+          if (captured.has(subToken.role)) {
+            score += weight;
+          } else if (roleHasDefault) {
+            score += weight * 0.6;
+          }
+        }
+      }
+    }
+  }
+  const roleCoverage = maxScore > 0 ? score / maxScore : 1;
+  let baseConfidence = roleCoverage;
+  let stemPenalty = 0;
+  if (ctx.stemMatchCount > 0 && ctx.totalKeywordMatches > 0) {
+    stemPenalty = ctx.stemMatchCount / ctx.totalKeywordMatches * 0.15;
+    baseConfidence = Math.max(0.5, baseConfidence - stemPenalty);
+  }
+  const vsoBoost = calculateVSOConfidenceBoost(pattern);
+  baseConfidence = Math.min(1, baseConfidence + vsoBoost);
+  const prepositionAdjustment = arabicPrepositionDisambiguation(pattern, captured);
+  baseConfidence = Math.max(0, Math.min(1, baseConfidence + prepositionAdjustment));
+  return {
+    roleCoverage,
+    stemPenalty,
+    languageBoost: vsoBoost,
+    languageAdjustment: prepositionAdjustment,
+    final: baseConfidence
+  };
+}
+function calculateVSOConfidenceBoost(pattern) {
+  if (pattern.language !== "ar") {
+    return 0;
+  }
+  const firstToken = pattern.template.tokens[0];
+  if (!firstToken || firstToken.type !== "literal") {
+    return 0;
+  }
+  const ARABIC_VERBS = /* @__PURE__ */ new Set([
+    "\u0628\u062F\u0644",
+    "\u063A\u064A\u0631",
+    "\u0623\u0636\u0641",
+    "\u0623\u0632\u0644",
+    "\u0636\u0639",
+    "\u0627\u062C\u0639\u0644",
+    "\u0639\u064A\u0646",
+    "\u0632\u062F",
+    "\u0627\u0646\u0642\u0635",
+    "\u0633\u062C\u0644",
+    "\u0623\u0638\u0647\u0631",
+    "\u0623\u062E\u0641",
+    "\u0634\u063A\u0644",
+    "\u0623\u0631\u0633\u0644",
+    "\u0631\u0643\u0632",
+    "\u0634\u0648\u0634",
+    "\u062A\u0648\u0642\u0641",
+    "\u0627\u0646\u0633\u062E",
+    "\u0627\u062D\u0630\u0641",
+    "\u0627\u0635\u0646\u0639",
+    "\u0627\u0646\u062A\u0638\u0631",
+    "\u0627\u0646\u062A\u0642\u0627\u0644",
+    "\u0623\u0648"
+  ]);
+  if (ARABIC_VERBS.has(firstToken.value)) {
+    return 0.15;
+  }
+  if (firstToken.alternatives) {
+    for (const alt of firstToken.alternatives) {
+      if (ARABIC_VERBS.has(alt)) {
+        return 0.15;
+      }
+    }
+  }
+  return 0;
+}
+function arabicPrepositionDisambiguation(pattern, captured) {
+  if (pattern.language !== "ar") {
+    return 0;
+  }
+  let adjustment = 0;
+  const PREFERRED_PREPOSITIONS = {
+    patient: ["\u0639\u0644\u0649"],
+    // element selectors prefer على (on/upon)
+    destination: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
+    // destination prefers إلى (to)
+    source: ["\u0645\u0646"],
+    // source prefers من (from)
+    agent: ["\u0645\u0646"],
+    // agent/by prefers من (from/by)
+    manner: ["\u0628"],
+    // manner prefers ب (with/by)
+    style: ["\u0628"],
+    // style prefers ب (with)
+    goal: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
+    // target state prefers إلى (to)
+    method: ["\u0628"]
+    // method prefers ب (with/by)
+  };
+  for (const [role, value] of captured.entries()) {
+    const preferred = PREFERRED_PREPOSITIONS[role];
+    if (!preferred || preferred.length === 0) {
+      continue;
+    }
+    const metadata = "metadata" in value ? value.metadata : void 0;
+    if (metadata && typeof metadata.prepositionValue === "string") {
+      const usedPreposition = metadata.prepositionValue;
+      if (preferred.includes(usedPreposition)) {
+        adjustment += 0.1;
+      } else {
+        adjustment -= 0.1;
+      }
+    }
+  }
+  return Math.max(-0.1, Math.min(0.1, adjustment));
+}
+var stockConfidenceModel = {
+  calculate: (ctx) => scoreParts(ctx).final,
+  calculateWithBreakdown: (ctx) => scoreParts(ctx)
+};
+
+// src/core/pattern-matching/pattern-matcher.ts
 var _PatternMatcher = class _PatternMatcher {
   constructor() {
     /** Debug logger */
@@ -123,19 +648,6 @@ var _PatternMatcher = class _PatternMatcher {
     this.stemMatchCount = 0;
     this.totalKeywordMatches = 0;
   }
-  /**
-   * Safely convert a value to lowercase string.
-   * Provides protection against non-string values at runtime.
-   */
-  safeToLowerCase(value) {
-    if (typeof value === "string") {
-      return value.toLowerCase();
-    }
-    if (value === null || value === void 0) {
-      return "";
-    }
-    return String(value).toLowerCase();
-  }
   /**
    * Try to match a single pattern against the token stream.
    * Returns the match result or null if no match.
@@ -184,7 +696,12 @@ var _PatternMatcher = class _PatternMatcher {
       tokens.reset(mark);
       return null;
     }
-    const confidence = this.calculateConfidence(pattern, captured);
+    const confidence = stockConfidenceModel.calculate({
+      pattern,
+      captured,
+      stemMatchCount: this.stemMatchCount,
+      totalKeywordMatches: this.totalKeywordMatches
+    });
     this.applyExtractionRules(pattern, captured);
     return {
       pattern,
@@ -369,7 +886,7 @@ var _PatternMatcher = class _PatternMatcher {
       case "literal":
         return this.matchLiteralToken(tokens, patternToken);
       case "role":
-        return this.matchRoleToken(tokens, patternToken, captured);
+        return readRoleValue(tokens, patternToken, captured, this.currentProfile);
       case "group":
         return this.matchGroupToken(tokens, patternToken, captured);
       default:
@@ -426,372 +943,6 @@ var _PatternMatcher = class _PatternMatcher {
     }
     return false;
   }
-  /**
-   * Match a role pattern token (captures a semantic value).
-   * Handles multi-token expressions like:
-   * - 'my value' (possessive keyword + property)
-   * - '#dialog.showModal()' (method call)
-   * - "#element's *opacity" (possessive selector + property)
-   */
-  matchRoleToken(tokens, patternToken, captured) {
-    this.logger.debug("    >>> matchRoleToken ENTRY: capturing role", patternToken.role);
-    this.logger.debug("    >>> matchRoleToken: expected types", patternToken.expectedTypes);
-    this.logger.debug("    >>> matchRoleToken: optional?", patternToken.optional);
-    this.skipNoiseWords(tokens);
-    const token = tokens.peek();
-    this.logger.debug(
-      "    >>> After skipNoiseWords, current token:",
-      token ? JSON.stringify({ value: token.value, kind: token.kind }) : "null"
-    );
-    if (!token) {
-      return patternToken.optional || false;
-    }
-    const possessiveValue = this.tryMatchPossessiveExpression(tokens);
-    if (possessiveValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(possessiveValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, possessiveValue);
-      return true;
-    }
-    const methodCallValue = this.tryMatchMethodCallExpression(tokens);
-    if (methodCallValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(methodCallValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, methodCallValue);
-      return true;
-    }
-    const possessiveSelectorValue = this.tryMatchPossessiveSelectorExpression(tokens);
-    if (possessiveSelectorValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(possessiveSelectorValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, possessiveSelectorValue);
-      return true;
-    }
-    const propertyAccessValue = this.tryMatchPropertyAccessExpression(tokens);
-    if (propertyAccessValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(propertyAccessValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, propertyAccessValue);
-      return true;
-    }
-    const selectorPropertyValue = this.tryMatchSelectorPropertyExpression(tokens);
-    if (selectorPropertyValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(selectorPropertyValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, selectorPropertyValue);
-      return true;
-    }
-    this.logger.debug(
-      "    >>> Trying tokenToSemanticValue for token:",
-      token ? JSON.stringify({ value: token.value, kind: token.kind }) : "null"
-    );
-    const value = this.tokenToSemanticValue(token);
-    this.logger.debug(
-      "    >>> tokenToSemanticValue returned:",
-      value ? JSON.stringify(value) : "null"
-    );
-    if (!value) {
-      return patternToken.optional || false;
-    }
-    this.logger.debug(
-      "    >>> Validating type:",
-      value.type,
-      "against expected:",
-      patternToken.expectedTypes
-    );
-    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-      if (!isTypeCompatible(value.type, patternToken.expectedTypes)) {
-        this.logger.debug("    >>> TYPE MISMATCH - returning", patternToken.optional || false);
-        return patternToken.optional || false;
-      }
-    }
-    this.logger.debug("    >>> Type validation PASSED");
-    captured.set(patternToken.role, value);
-    tokens.advance();
-    return true;
-  }
-  /**
-   * Try to match a possessive expression like 'my value' or 'its innerHTML'.
-   * Returns the PropertyPathValue if matched, or null if not.
-   */
-  tryMatchPossessiveExpression(tokens) {
-    const token = tokens.peek();
-    if (!token) return null;
-    if (!this.currentProfile) return null;
-    const tokenValue = token.normalized || token.value;
-    const tokenLower = this.safeToLowerCase(tokenValue);
-    const baseRef = getPossessiveReference(this.currentProfile, tokenLower);
-    if (!baseRef) return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken) {
-      tokens.reset(mark);
-      return null;
-    }
-    if (propertyToken.kind === "identifier" || propertyToken.kind === "keyword" && !this.isStructuralKeyword(propertyToken.value) || propertyToken.kind === "selector" && propertyToken.value.startsWith("*") || propertyToken.kind === "selector" && propertyToken.value.startsWith("@") || propertyToken.kind === "selector" && propertyToken.value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyToken.value)) {
-      tokens.advance();
-      let propertyName = propertyToken.value;
-      if (propertyToken.kind === "selector" && propertyName.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyName)) {
-        propertyName = propertyName.substring(1);
-      }
-      let chainedProps = propertyName;
-      while (tokens.peek()?.kind === "selector" && tokens.peek().value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(tokens.peek().value)) {
-        chainedProps += tokens.peek().value;
-        tokens.advance();
-      }
-      const nextPeek = tokens.peek();
-      if (nextPeek?.kind === "literal" && nextPeek.value.startsWith("(")) {
-        chainedProps += nextPeek.value;
-        tokens.advance();
-      }
-      return createPropertyPath(createReference(baseRef), chainedProps);
-    }
-    tokens.reset(mark);
-    return null;
-  }
-  /**
-   * Check if a keyword is a structural keyword (preposition, control flow, etc.)
-   * that shouldn't be consumed as a property name.
-   */
-  isStructuralKeyword(value) {
-    const structural = /* @__PURE__ */ new Set([
-      // Prepositions
-      "into",
-      "in",
-      "to",
-      "from",
-      "at",
-      "by",
-      "with",
-      "without",
-      "before",
-      "after",
-      "of",
-      "as",
-      "on",
-      // Control flow
-      "then",
-      "end",
-      "else",
-      "if",
-      "repeat",
-      "while",
-      "for",
-      // Commands (shouldn't be property names)
-      "toggle",
-      "add",
-      "remove",
-      "put",
-      "set",
-      "show",
-      "hide",
-      "increment",
-      "decrement",
-      "send",
-      "trigger",
-      "call"
-    ]);
-    return structural.has(value.toLowerCase());
-  }
-  /**
-   * Try to match a method call expression like '#dialog.showModal()'.
-   * Pattern: selector + '.' + identifier + '(' + [args] + ')'
-   * Returns an expression value if matched, or null if not.
-   */
-  tryMatchMethodCallExpression(tokens) {
-    const token = tokens.peek();
-    if (!token || token.kind !== "selector") return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const dotToken = tokens.peek();
-    if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const methodToken = tokens.peek();
-    if (!methodToken || methodToken.kind !== "identifier") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const openParen = tokens.peek();
-    if (!openParen || openParen.kind !== "punctuation" || openParen.value !== "(") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const args = [];
-    while (!tokens.isAtEnd() && args.length < _PatternMatcher.MAX_METHOD_ARGS) {
-      const argToken = tokens.peek();
-      if (!argToken) break;
-      if (argToken.kind === "punctuation" && argToken.value === ")") {
-        tokens.advance();
-        break;
-      }
-      if (argToken.kind === "punctuation" && argToken.value === ",") {
-        tokens.advance();
-        continue;
-      }
-      args.push(argToken.value);
-      tokens.advance();
-    }
-    const methodCall = `${token.value}.${methodToken.value}(${args.join(", ")})`;
-    return {
-      type: "expression",
-      raw: methodCall
-    };
-  }
-  /**
-   * Try to match a property access expression like 'userData.name' or 'it.data'.
-   * Pattern: (identifier | keyword) + '.' + identifier [+ '.' + identifier ...]
-   * Returns an expression value if matched, or null if not.
-   */
-  tryMatchPropertyAccessExpression(tokens) {
-    const token = tokens.peek();
-    if (!token) return null;
-    if (token.kind !== "identifier" && token.kind !== "keyword") return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const dotToken = tokens.peek();
-    if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken || propertyToken.kind !== "identifier") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    let chain = `${token.value}.${propertyToken.value}`;
-    let depth = 1;
-    while (!tokens.isAtEnd() && depth < _PatternMatcher.MAX_PROPERTY_DEPTH) {
-      const nextDot = tokens.peek();
-      if (!nextDot || nextDot.kind !== "operator" || nextDot.value !== ".") {
-        break;
-      }
-      tokens.advance();
-      const nextProp = tokens.peek();
-      if (!nextProp || nextProp.kind !== "identifier") {
-        break;
-      }
-      tokens.advance();
-      chain += `.${nextProp.value}`;
-      depth++;
-    }
-    const openParen = tokens.peek();
-    if (openParen && openParen.kind === "punctuation" && openParen.value === "(") {
-      tokens.advance();
-      const args = [];
-      let argDepth = 0;
-      while (!tokens.isAtEnd() && args.length < _PatternMatcher.MAX_METHOD_ARGS) {
-        const argToken = tokens.peek();
-        if (!argToken) break;
-        if (argToken.kind === "punctuation" && argToken.value === ")") {
-          if (argDepth === 0) {
-            tokens.advance();
-            break;
-          }
-          argDepth--;
-        }
-        if (argToken.kind === "punctuation" && argToken.value === "(") {
-          argDepth++;
-        }
-        if (argToken.kind === "punctuation" && argToken.value === ",") {
-          tokens.advance();
-          continue;
-        }
-        args.push(argToken.value);
-        tokens.advance();
-      }
-      const methodCall = `${chain}(${args.join(", ")})`;
-      return {
-        type: "expression",
-        raw: methodCall
-      };
-    }
-    return {
-      type: "expression",
-      raw: chain
-    };
-  }
-  /**
-   * Try to match a possessive selector expression like "#element's *opacity".
-   * Pattern: selector + "'s" + (selector | identifier)
-   * Returns a property-path value if matched, or null if not.
-   */
-  tryMatchPossessiveSelectorExpression(tokens) {
-    const token = tokens.peek();
-    if (!token || token.kind !== "selector") return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const possessiveToken = tokens.peek();
-    if (!possessiveToken || possessiveToken.kind !== "punctuation" || possessiveToken.value !== "'s") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken) {
-      tokens.reset(mark);
-      return null;
-    }
-    if (propertyToken.kind !== "selector" && propertyToken.kind !== "identifier") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    return createPropertyPath(createSelector(token.value), propertyToken.value);
-  }
-  /**
-   * Try to match a selector + property expression like "#output.innerText".
-   * This handles cases where the tokenizer produces two selector tokens:
-   * - #output (id selector)
-   * - .innerText (looks like class selector, but is actually property)
-   *
-   * Pattern: id-selector + class-selector-that-is-actually-property
-   * Returns a property-path value if matched, or null if not.
-   */
-  tryMatchSelectorPropertyExpression(tokens) {
-    const token = tokens.peek();
-    if (!token || token.kind !== "selector") return null;
-    if (typeof token.value !== "string" || !token.value.startsWith("#")) return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken || propertyToken.kind !== "selector") {
-      tokens.reset(mark);
-      return null;
-    }
-    if (!propertyToken.value.startsWith(".")) {
-      tokens.reset(mark);
-      return null;
-    }
-    const peek2 = tokens.peek(1);
-    if (peek2 && peek2.kind === "selector") {
-    }
-    tokens.advance();
-    const propertyName = propertyToken.value.slice(1);
-    return createPropertyPath(createSelector(token.value), propertyName);
-  }
   /**
    * Match a group pattern token (optional sequence).
    * When the group's leading marker isn't at the current position, scans ahead
@@ -867,7 +1018,7 @@ var _PatternMatcher = class _PatternMatcher {
     if (token.stem === value && token.stemConfidence !== void 0 && token.stemConfidence >= 0.7) {
       return "stem";
     }
-    if (token.kind === "keyword" && this.safeToLowerCase(token.value) === value.toLowerCase()) {
+    if (token.kind === "keyword" && safeToLowerCase(token.value) === value.toLowerCase()) {
       return "case-insensitive";
     }
     return "none";
@@ -915,62 +1066,9 @@ var _PatternMatcher = class _PatternMatcher {
     if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
     return false;
   }
-  /**
-   * Convert a language token to a semantic value.
-   */
-  tokenToSemanticValue(token) {
-    switch (token.kind) {
-      case "selector":
-        return createSelector(token.value);
-      case "literal":
-        return this.parseLiteralValue(token.value);
-      case "keyword":
-        const tokenValue = token.normalized || token.value;
-        const lower = this.safeToLowerCase(tokenValue);
-        if (isValidReference(lower)) {
-          return createReference(lower);
-        }
-        return createLiteral(token.normalized || token.value);
-      case "identifier":
-        if (typeof token.value === "string" && token.value.startsWith(":")) {
-          return createReference(token.value);
-        }
-        const identLower = this.safeToLowerCase(token.value);
-        if (isValidReference(identLower)) {
-          return createReference(identLower);
-        }
-        return { type: "expression", raw: token.value };
-      case "url":
-        return createLiteral(token.value, "string");
-      default:
-        return null;
-    }
-  }
-  /**
-   * Parse a literal value (string, number, boolean).
-   */
-  parseLiteralValue(value) {
-    if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
-      const inner = value.slice(1, -1);
-      return createLiteral(inner, "string");
-    }
-    if (value === "true") return createLiteral(true, "boolean");
-    if (value === "false") return createLiteral(false, "boolean");
-    const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
-    if (durationMatch) {
-      const num2 = parseFloat(durationMatch[1]);
-      const unit = durationMatch[2];
-      if (unit) {
-        return createLiteral(value, "duration");
-      }
-      return createLiteral(num2, "number");
-    }
-    const num = parseFloat(value);
-    if (!isNaN(num)) {
-      return createLiteral(num, "number");
-    }
-    return createLiteral(value, "string");
-  }
+  // ==========================================================================
+  // Depth Limits for Expression Parsing (security hardening)
+  // ==========================================================================
   /**
    * Apply extraction rules to fill in static values and defaults for missing roles.
    */
@@ -991,190 +1089,9 @@ var _PatternMatcher = class _PatternMatcher {
   isOptional(patternToken) {
     return patternToken.type !== "literal" && patternToken.optional === true;
   }
-  /**
-   * Calculate confidence score for a match (0-1).
-   *
-   * Confidence is reduced for:
-   * - Stem matches (morphological normalization has inherent uncertainty)
-   * - Missing optional roles (but less penalty if role has a default value)
-   *
-   * Confidence is increased for:
-   * - VSO languages (Arabic) when pattern starts with a verb
-   */
-  calculateConfidence(pattern, captured) {
-    let score = 0;
-    let maxScore = 0;
-    const hasDefault = (role) => {
-      return pattern.extraction?.[role]?.default !== void 0;
-    };
-    for (const token of pattern.template.tokens) {
-      if (token.type === "role") {
-        maxScore += 1;
-        if (captured.has(token.role)) {
-          score += 1;
-        }
-      } else if (token.type === "group") {
-        for (const subToken of token.tokens) {
-          if (subToken.type === "role") {
-            const roleHasDefault = hasDefault(subToken.role);
-            const weight = 0.8;
-            maxScore += weight;
-            if (captured.has(subToken.role)) {
-              score += weight;
-            } else if (roleHasDefault) {
-              score += weight * 0.6;
-            }
-          }
-        }
-      }
-    }
-    let baseConfidence = maxScore > 0 ? score / maxScore : 1;
-    if (this.stemMatchCount > 0 && this.totalKeywordMatches > 0) {
-      const stemPenalty = this.stemMatchCount / this.totalKeywordMatches * 0.15;
-      baseConfidence = Math.max(0.5, baseConfidence - stemPenalty);
-    }
-    const vsoBoost = this.calculateVSOConfidenceBoost(pattern);
-    baseConfidence = Math.min(1, baseConfidence + vsoBoost);
-    const prepositionAdjustment = this.arabicPrepositionDisambiguation(pattern, captured);
-    baseConfidence = Math.max(0, Math.min(1, baseConfidence + prepositionAdjustment));
-    return baseConfidence;
-  }
-  /**
-   * Calculate confidence boost for VSO (Verb-Subject-Object) language patterns.
-   * Arabic naturally uses VSO word order, so patterns that start with a verb
-   * should receive a confidence boost.
-   *
-   * Returns +0.15 confidence boost if:
-   * - Language is Arabic ('ar')
-   * - Pattern's first token is a verb keyword
-   *
-   * @param pattern The language pattern being matched
-   * @returns Confidence boost (0 or 0.15)
-   */
-  calculateVSOConfidenceBoost(pattern) {
-    if (pattern.language !== "ar") {
-      return 0;
-    }
-    const firstToken = pattern.template.tokens[0];
-    if (!firstToken || firstToken.type !== "literal") {
-      return 0;
-    }
-    const ARABIC_VERBS = /* @__PURE__ */ new Set([
-      "\u0628\u062F\u0644",
-      "\u063A\u064A\u0631",
-      "\u0623\u0636\u0641",
-      "\u0623\u0632\u0644",
-      "\u0636\u0639",
-      "\u0627\u062C\u0639\u0644",
-      "\u0639\u064A\u0646",
-      "\u0632\u062F",
-      "\u0627\u0646\u0642\u0635",
-      "\u0633\u062C\u0644",
-      "\u0623\u0638\u0647\u0631",
-      "\u0623\u062E\u0641",
-      "\u0634\u063A\u0644",
-      "\u0623\u0631\u0633\u0644",
-      "\u0631\u0643\u0632",
-      "\u0634\u0648\u0634",
-      "\u062A\u0648\u0642\u0641",
-      "\u0627\u0646\u0633\u062E",
-      "\u0627\u062D\u0630\u0641",
-      "\u0627\u0635\u0646\u0639",
-      "\u0627\u0646\u062A\u0638\u0631",
-      "\u0627\u0646\u062A\u0642\u0627\u0644",
-      "\u0623\u0648"
-    ]);
-    if (ARABIC_VERBS.has(firstToken.value)) {
-      return 0.15;
-    }
-    if (firstToken.alternatives) {
-      for (const alt of firstToken.alternatives) {
-        if (ARABIC_VERBS.has(alt)) {
-          return 0.15;
-        }
-      }
-    }
-    return 0;
-  }
-  /**
-   * Arabic preposition disambiguation for confidence adjustment.
-   *
-   * Different Arabic prepositions are more or less natural for different semantic roles:
-   * - على (on/upon) is preferred for patient/target roles (element selectors)
-   * - إلى (to) is preferred for destination roles
-   * - من (from) is preferred for source roles
-   * - في (in) is preferred for location roles
-   *
-   * This method analyzes the prepositions used with captured semantic roles and
-   * adjusts confidence based on idiomaticity:
-   * - +0.10 for highly idiomatic preposition choices
-   * - -0.10 for less natural preposition choices
-   *
-   * @param pattern The language pattern being matched
-   * @param captured The captured semantic values
-   * @returns Confidence adjustment (-0.10 to +0.10)
-   */
-  arabicPrepositionDisambiguation(pattern, captured) {
-    if (pattern.language !== "ar") {
-      return 0;
-    }
-    let adjustment = 0;
-    const PREFERRED_PREPOSITIONS = {
-      patient: ["\u0639\u0644\u0649"],
-      // element selectors prefer على (on/upon)
-      destination: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
-      // destination prefers إلى (to)
-      source: ["\u0645\u0646"],
-      // source prefers من (from)
-      agent: ["\u0645\u0646"],
-      // agent/by prefers من (from/by)
-      manner: ["\u0628"],
-      // manner prefers ب (with/by)
-      style: ["\u0628"],
-      // style prefers ب (with)
-      goal: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
-      // target state prefers إلى (to)
-      method: ["\u0628"]
-      // method prefers ب (with/by)
-    };
-    for (const [role, value] of captured.entries()) {
-      const preferred = PREFERRED_PREPOSITIONS[role];
-      if (!preferred || preferred.length === 0) {
-        continue;
-      }
-      const metadata = "metadata" in value ? value.metadata : void 0;
-      if (metadata && typeof metadata.prepositionValue === "string") {
-        const usedPreposition = metadata.prepositionValue;
-        if (preferred.includes(usedPreposition)) {
-          adjustment += 0.1;
-        } else {
-          adjustment -= 0.1;
-        }
-      }
-    }
-    return Math.max(-0.1, Math.min(0.1, adjustment));
-  }
-  /**
-   * Skip noise words like "the" before selectors.
-   * This enables more natural English syntax like "toggle the .active".
-   */
-  skipNoiseWords(tokens) {
-    const token = tokens.peek();
-    if (!token) return;
-    const tokenLower = this.safeToLowerCase(token.value);
-    if (_PatternMatcher.ENGLISH_NOISE_WORDS.has(tokenLower)) {
-      const mark = tokens.mark();
-      tokens.advance();
-      const nextToken = tokens.peek();
-      if (nextToken && nextToken.kind === "selector") {
-        return;
-      }
-      tokens.reset(mark);
-    }
-    if (tokenLower === "class") {
-      tokens.advance();
-    }
-  }
+  // ===========================================================================
+  // English Idiom Support - Noise Word Handling
+  // ===========================================================================
   /**
    * Extract event modifiers from the token stream.
    * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
@@ -1222,22 +1139,6 @@ var _PatternMatcher = class _PatternMatcher {
 };
 /** Maximum tokens to scan ahead when looking for a group's leading marker */
 _PatternMatcher.MAX_MARKER_SCAN = 3;
-// ==========================================================================
-// Depth Limits for Expression Parsing (security hardening)
-// ==========================================================================
-/** Maximum depth for nested property access (e.g., a.b.c.d...) */
-_PatternMatcher.MAX_PROPERTY_DEPTH = 10;
-/** Maximum number of arguments in method calls */
-_PatternMatcher.MAX_METHOD_ARGS = 20;
-// ===========================================================================
-// English Idiom Support - Noise Word Handling
-// ===========================================================================
-/**
- * Noise words that can be skipped in English for more natural syntax.
- * - "the" before selectors: "toggle the .active" → "toggle .active"
- * - "class" after class selectors: "add the .visible class" → "add .visible"
- */
-_PatternMatcher.ENGLISH_NOISE_WORDS = /* @__PURE__ */ new Set(["the", "a", "an"]);
 var PatternMatcher = _PatternMatcher;
 var patternMatcher = new PatternMatcher();