@lokascript/framework 4.8.0 → 5.1.0

package/dist/parsing/index.js

@@ -1,1147 +1,3 @@
-// src/core/logger.ts
-var DebugLogger = class {
-  constructor(namespace) {
-    this.namespace = namespace;
-    this.enabled = this.checkEnabled();
-  }
-  checkEnabled() {
-    if (typeof process !== "undefined" && process.env) {
-      const DEBUG = process.env.DEBUG || "";
-      return DEBUG === "*" || DEBUG.includes("framework:*") || DEBUG.includes(`framework:${this.namespace}`);
-    }
-    return false;
-  }
-  log(level, message, ...args) {
-    if (!this.enabled) return;
-    const prefix = `[framework:${this.namespace}]`;
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    switch (level) {
-      case "debug":
-        console.debug(`${timestamp} ${prefix} DEBUG:`, message, ...args);
-        break;
-      case "info":
-        console.info(`${timestamp} ${prefix} INFO:`, message, ...args);
-        break;
-      case "warn":
-        console.warn(`${timestamp} ${prefix} WARN:`, message, ...args);
-        break;
-      case "error":
-        console.error(`${timestamp} ${prefix} ERROR:`, message, ...args);
-        break;
-    }
-  }
-  debug(message, ...args) {
-    this.log("debug", message, ...args);
-  }
-  info(message, ...args) {
-    this.log("info", message, ...args);
-  }
-  warn(message, ...args) {
-    this.log("warn", message, ...args);
-  }
-  error(message, ...args) {
-    this.log("error", message, ...args);
-  }
-  /**
-   * Check if logging is enabled for this namespace.
-   */
-  isEnabled() {
-    return this.enabled;
-  }
-  /**
-   * Programmatically enable logging for this namespace.
-   */
-  enable() {
-    this.enabled = true;
-  }
-  /**
-   * Programmatically disable logging for this namespace.
-   */
-  disable() {
-    this.enabled = false;
-  }
-};
-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) {
-    return true;
-  }
-  if (expectedTypes.includes(actualType)) {
-    return true;
-  }
-  if (expectedTypes.includes("expression")) {
-    return true;
-  }
-  if (actualType === "property-path") {
-    return expectedTypes.some((t) => ["selector", "reference", "expression"].includes(t));
-  }
-  return false;
-}
-
-// src/core/pattern-matching/utils/possessive-keywords.ts
-function getPossessiveReference(profile, keyword) {
-  return profile?.possessive?.keywords?.[keyword];
-}
-
-// 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 */
-    this.logger = createLogger("pattern-matcher");
-    /**
-     * Track stem matches for confidence calculation.
-     * This is set during matching and read during confidence calculation.
-     */
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-  }
-  /**
-   * Try to match a single pattern against the token stream.
-   * Returns the match result or null if no match.
-   *
-   * @param tokens - Token stream to match against
-   * @param pattern - Pattern to match
-   * @param profile - Optional language profile for possessive handling
-   */
-  matchPattern(tokens, pattern, profile) {
-    const mark = tokens.mark();
-    const captured = /* @__PURE__ */ new Map();
-    this.logger.debug("========================================");
-    this.logger.debug("matchPattern ENTRY");
-    this.logger.debug("Pattern ID:", pattern.id);
-    this.logger.debug("Pattern command:", pattern.command);
-    this.logger.debug("Pattern language:", pattern.language);
-    this.logger.debug("Pattern template:", JSON.stringify(pattern.template, null, 2));
-    if (this.logger.isEnabled()) {
-      const firstTokens = [];
-      for (let i = 0; i < 10; i++) {
-        const t = tokens.peek(i);
-        if (t)
-          firstTokens.push({
-            type: t.type,
-            value: t.value,
-            kind: t.kind
-          });
-        else break;
-      }
-      this.logger.debug("Input tokens (first 10):", firstTokens);
-      this.logger.debug("Profile code:", profile?.code);
-    }
-    this.currentProfile = profile;
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-    this.logger.debug("--- Calling matchTokenSequence ---");
-    this.logger.debug("Pattern tokens to match:", JSON.stringify(pattern.template.tokens, null, 2));
-    const success = this.matchTokenSequence(tokens, pattern.template.tokens, captured);
-    this.logger.debug("matchTokenSequence returned:", success);
-    this.logger.debug(
-      "Captured roles:",
-      Array.from(captured.entries()).map(([k, v]) => [k, JSON.stringify(v)])
-    );
-    if (!success) {
-      this.logger.debug(">>> MATCH FAILED - resetting token position");
-      tokens.reset(mark);
-      return null;
-    }
-    const confidence = stockConfidenceModel.calculate({
-      pattern,
-      captured,
-      stemMatchCount: this.stemMatchCount,
-      totalKeywordMatches: this.totalKeywordMatches
-    });
-    this.applyExtractionRules(pattern, captured);
-    return {
-      pattern,
-      captured,
-      consumedTokens: tokens.position() - mark.position,
-      confidence
-    };
-  }
-  /**
-   * Try to match multiple patterns, return the best match.
-   *
-   * @param tokens - Token stream to match against
-   * @param patterns - Candidate patterns to try
-   * @param profile - Optional language profile for possessive handling
-   */
-  matchBest(tokens, patterns, profile) {
-    const matches = [];
-    for (const pattern of patterns) {
-      const mark = tokens.mark();
-      const result = this.matchPattern(tokens, pattern, profile);
-      if (result) {
-        matches.push(result);
-      }
-      tokens.reset(mark);
-    }
-    if (matches.length === 0) {
-      return null;
-    }
-    matches.sort((a, b) => {
-      const priorityDiff = b.pattern.priority - a.pattern.priority;
-      if (priorityDiff !== 0) return priorityDiff;
-      const confidenceDiff = b.confidence - a.confidence;
-      if (Math.abs(confidenceDiff) > 1e-3) return confidenceDiff;
-      return b.consumedTokens - a.consumedTokens;
-    });
-    const best = matches[0];
-    this.matchPattern(tokens, best.pattern);
-    return best;
-  }
-  /**
-   * Match a sequence of pattern tokens against the token stream.
-   *
-   * Supports bounded single-step backtracking: if an optional role consumes
-   * 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, 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) {
-      while (tokens.peek()?.kind === "conjunction") {
-        tokens.advance();
-      }
-    }
-    let prevOptionalMark = null;
-    let prevOptionalRole = null;
-    for (let i = 0; i < patternTokens.length; i++) {
-      const patternToken = patternTokens[i];
-      this.logger.debug("  >> Matching pattern token:", JSON.stringify(patternToken, null, 2));
-      const currTok = tokens.peek();
-      this.logger.debug(
-        "  >> Current input token:",
-        currTok ? JSON.stringify({
-          type: currTok.type,
-          value: currTok.value,
-          kind: currTok.kind
-        }) : "EOF"
-      );
-      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();
-          if (!nextToken) break;
-          if (this.isStopMarker(nextToken, stopMarkers)) break;
-          values.push(nextToken.value);
-          tokens.advance();
-        }
-        if (values.length > 0) {
-          captured.set(patternToken.role, { type: "expression", raw: values.join(" ") });
-          prevOptionalMark = null;
-          prevOptionalRole = null;
-          continue;
-        } else if (patternToken.optional) {
-          continue;
-        } else {
-          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) {
-        if (isOptionalRole) {
-          prevOptionalMark = markBefore;
-          prevOptionalRole = patternToken.role;
-        } else {
-          prevOptionalMark = null;
-          prevOptionalRole = null;
-        }
-        continue;
-      }
-      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;
-    }
-    return true;
-  }
-  /**
-   * Match a single pattern token against the current position in the stream.
-   */
-  matchPatternToken(tokens, patternToken, captured) {
-    switch (patternToken.type) {
-      case "literal":
-        return this.matchLiteralToken(tokens, patternToken);
-      case "role":
-        return readRoleValue(tokens, patternToken, captured, this.currentProfile);
-      case "group":
-        return this.matchGroupToken(tokens, patternToken, captured);
-      default:
-        return false;
-    }
-  }
-  /**
-   * Match a literal pattern token (keyword or particle).
-   */
-  matchLiteralToken(tokens, patternToken) {
-    const token = tokens.peek();
-    this.logger.debug("    >>> matchLiteralToken: expecting", patternToken.value);
-    this.logger.debug(
-      "    >>> matchLiteralToken: got token",
-      token ? JSON.stringify({
-        type: token.type,
-        value: token.value,
-        kind: token.kind
-      }) : "null"
-    );
-    if (!token) {
-      this.logger.debug("    >>> matchLiteralToken: FAIL - no token");
-      return false;
-    }
-    const matchType = this.getMatchType(token, patternToken.value);
-    this.logger.debug(
-      "    >>> matchType for",
-      token.value,
-      "vs",
-      patternToken.value,
-      ":",
-      matchType
-    );
-    if (matchType !== "none") {
-      this.totalKeywordMatches++;
-      if (matchType === "stem") {
-        this.stemMatchCount++;
-      }
-      tokens.advance();
-      return true;
-    }
-    if (patternToken.alternatives) {
-      for (const alt of patternToken.alternatives) {
-        const altMatchType = this.getMatchType(token, alt);
-        if (altMatchType !== "none") {
-          this.totalKeywordMatches++;
-          if (altMatchType === "stem") {
-            this.stemMatchCount++;
-          }
-          tokens.advance();
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  /**
-   * Match a group pattern token (optional sequence).
-   * When the group's leading marker isn't at the current position, scans ahead
-   * up to MAX_MARKER_SCAN tokens to find it. This allows unmarked tokens
-   * (e.g., a value like 'hello') to sit between groups without blocking later
-   * marker matches.
-   */
-  matchGroupToken(tokens, patternToken, captured, parentStopMarkers) {
-    const mark = tokens.mark();
-    const capturedBefore = new Set(captured.keys());
-    const success = this.matchTokenSequence(
-      tokens,
-      patternToken.tokens,
-      captured,
-      parentStopMarkers
-    );
-    if (success) return true;
-    tokens.reset(mark);
-    for (const role of captured.keys()) {
-      if (!capturedBefore.has(role)) captured.delete(role);
-    }
-    if (!patternToken.optional) return false;
-    const leadingMarker = this.getGroupLeadingMarker(patternToken);
-    if (leadingMarker) {
-      for (let offset = 1; offset <= _PatternMatcher.MAX_MARKER_SCAN; offset++) {
-        const ahead = tokens.peek(offset);
-        if (!ahead) break;
-        const aheadValue = (ahead.normalized || ahead.value).toLowerCase();
-        if (aheadValue === leadingMarker) {
-          this.logger.debug(
-            "  >> MARKER SCAN: found",
-            leadingMarker,
-            "at offset",
-            offset,
-            "- skipping intervening tokens"
-          );
-          for (let s = 0; s < offset; s++) tokens.advance();
-          const retrySuccess = this.matchTokenSequence(
-            tokens,
-            patternToken.tokens,
-            captured,
-            parentStopMarkers
-          );
-          if (retrySuccess) return true;
-          tokens.reset(mark);
-          for (const role of captured.keys()) {
-            if (!capturedBefore.has(role)) captured.delete(role);
-          }
-          break;
-        }
-      }
-    }
-    return true;
-  }
-  /**
-   * Get the leading marker literal from an optional group.
-   * Returns the lowercase marker value, or null if the group
-   * doesn't start with a literal token (e.g., SOV groups where
-   * the role comes before the marker).
-   */
-  getGroupLeadingMarker(group) {
-    const first = group.tokens[0];
-    if (first?.type === "literal") return first.value.toLowerCase();
-    return null;
-  }
-  /**
-   * Get the type of match for a token against a value.
-   * Used for confidence calculation.
-   */
-  getMatchType(token, value) {
-    if (token.value === value) return "exact";
-    if (token.normalized === value) return "normalized";
-    if (token.stem === value && token.stemConfidence !== void 0 && token.stemConfidence >= 0.7) {
-      return "stem";
-    }
-    if (token.kind === "keyword" && safeToLowerCase(token.value) === value.toLowerCase()) {
-      return "case-insensitive";
-    }
-    return "none";
-  }
-  /**
-   * Collect literal values from upcoming pattern tokens that act as stop markers
-   * for greedy role capture. Returns the set of lowercase values.
-   */
-  collectStopMarkers(patternTokens, startIndex) {
-    const markers = /* @__PURE__ */ new Set();
-    for (let j = startIndex; j < patternTokens.length; j++) {
-      const pt = patternTokens[j];
-      if (pt.type === "literal") {
-        markers.add(pt.value.toLowerCase());
-        if (pt.alternatives) {
-          for (const alt of pt.alternatives) {
-            markers.add(alt.toLowerCase());
-          }
-        }
-        break;
-      }
-      if (pt.type === "group") {
-        for (const gt of pt.tokens) {
-          if (gt.type === "literal") {
-            markers.add(gt.value.toLowerCase());
-            if (gt.alternatives) {
-              for (const alt of gt.alternatives) {
-                markers.add(alt.toLowerCase());
-              }
-            }
-            break;
-          }
-        }
-        if (!pt.optional) break;
-      }
-    }
-    return markers;
-  }
-  /**
-   * Check if a token matches any stop marker for greedy capture.
-   */
-  isStopMarker(token, stopMarkers) {
-    if (stopMarkers.size === 0) return false;
-    if (stopMarkers.has(token.value.toLowerCase())) return true;
-    if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
-    return false;
-  }
-  // ==========================================================================
-  // Depth Limits for Expression Parsing (security hardening)
-  // ==========================================================================
-  /**
-   * Apply extraction rules to fill in static values and defaults for missing roles.
-   */
-  applyExtractionRules(pattern, captured) {
-    for (const [role, rule] of Object.entries(pattern.extraction)) {
-      if (!captured.has(role)) {
-        if (rule.value !== void 0) {
-          captured.set(role, { type: "literal", value: rule.value });
-        } else if (rule.default) {
-          captured.set(role, rule.default);
-        }
-      }
-    }
-  }
-  /**
-   * Check if a pattern token is optional.
-   */
-  isOptional(patternToken) {
-    return patternToken.type !== "literal" && patternToken.optional === true;
-  }
-  // ===========================================================================
-  // English Idiom Support - Noise Word Handling
-  // ===========================================================================
-  /**
-   * Extract event modifiers from the token stream.
-   * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
-   * that can appear after event names.
-   *
-   * Returns EventModifiers object or undefined if no modifiers found.
-   */
-  extractEventModifiers(tokens) {
-    const modifiers = {};
-    let foundModifier = false;
-    while (!tokens.isAtEnd()) {
-      const token = tokens.peek();
-      if (!token || token.kind !== "event-modifier") {
-        break;
-      }
-      const metadata = token.metadata;
-      if (!metadata) {
-        break;
-      }
-      foundModifier = true;
-      switch (metadata.modifierName) {
-        case "once":
-          modifiers.once = true;
-          break;
-        case "debounce":
-          if (typeof metadata.value === "number") {
-            modifiers.debounce = metadata.value;
-          }
-          break;
-        case "throttle":
-          if (typeof metadata.value === "number") {
-            modifiers.throttle = metadata.value;
-          }
-          break;
-        case "queue":
-          if (metadata.value === "first" || metadata.value === "last" || metadata.value === "all" || metadata.value === "none") {
-            modifiers.queue = metadata.value;
-          }
-          break;
-      }
-      tokens.advance();
-    }
-    return foundModifier ? modifiers : void 0;
-  }
-};
-/** Maximum tokens to scan ahead when looking for a group's leading marker */
-_PatternMatcher.MAX_MARKER_SCAN = 3;
-var PatternMatcher = _PatternMatcher;
-var patternMatcher = new PatternMatcher();
-
 // src/parsing/multi-statement.ts
 function createMultiStatementParser(dsl, config) {
   return new MultiStatementParserImpl(dsl, config);
@@ -1380,7 +236,6 @@ function accumulateIndented(statements, config) {
   return { blocks: rootBlocks, orphans };
 }
 export {
-  PatternMatcher,
   accumulateBlocks,
   createMultiStatementParser
 };