@lokascript/framework 4.8.0 → 5.1.0

package/dist/core/index.js

@@ -1678,89 +1678,387 @@ var BaseMorphologicalNormalizer = class {
   }
 };
 
-// src/core/logger.ts
-var DebugLogger = class {
-  constructor(namespace) {
-    this.namespace = namespace;
-    this.enabled = this.checkEnabled();
+// src/core/matching/match-skeleton.ts
+function groupHasRole(group) {
+  return group.tokens.some((t) => t.type === "role" || t.type === "group" && groupHasRole(t));
+}
+var MatchSkeleton = class {
+  /**
+   * @param makeReader - builds the grammar's reader, handed this matcher's view
+   *   of the match in progress (one reader per matcher).
+   */
+  constructor(makeReader, confidenceModel) {
+    /**
+     * The pattern tokens still to match after the one being matched, through
+     * every enclosing group: a value stops at any marker the pattern still owes.
+     */
+    this.patternRest = [];
+    /**
+     * Whether the role slot being matched directly follows a literal the pattern
+     * matched: its marker (`[por {quantity}]`), or the command's verb.
+     */
+    this.slotAfterLiteral = false;
+    /**
+     * Selective memoization cache (Phase 6.1).
+     * Caches pattern match results keyed by `tokenPosition:patternId`.
+     * Cleared before each top-level matchBest() call.
+     */
+    this.matchCache = /* @__PURE__ */ new Map();
+    /**
+     * Stream index where each role's capture began, for the current
+     * `matchPattern` call. Rebuilt per call, written on the same success path as
+     * `captured` — see `PatternMatchResult.roleStarts`.
+     */
+    this.roleStarts = /* @__PURE__ */ new Map();
+    /**
+     * Track stem matches for confidence calculation.
+     * This is set during matching and read during confidence calculation.
+     */
+    this.stemMatchCount = 0;
+    this.totalKeywordMatches = 0;
+    this.confidenceModel = confidenceModel;
+    this.reader = makeReader({
+      patternRest: () => this.patternRest,
+      slotAfterLiteral: () => this.slotAfterLiteral,
+      wouldMatch: (pt, token) => this.patternTokenWouldMatch(pt, token)
+    });
   }
-  checkEnabled() {
-    if (typeof process !== "undefined" && process.env) {
-      const DEBUG = process.env.DEBUG || "";
-      return DEBUG === "*" || DEBUG.includes("framework:*") || DEBUG.includes(`framework:${this.namespace}`);
+  /**
+   * Try to match a single pattern against the token stream.
+   * Returns the match result or null if no match.
+   */
+  matchPattern(tokens, pattern) {
+    const mark = tokens.mark();
+    const captured = /* @__PURE__ */ new Map();
+    this.reader.beginPattern(pattern);
+    this.stemMatchCount = 0;
+    this.totalKeywordMatches = 0;
+    this.roleStarts = /* @__PURE__ */ new Map();
+    this.patternRest = [];
+    const success = this.matchTokenSequence(tokens, pattern.template.tokens, captured);
+    if (!success) {
+      tokens.reset(mark);
+      return null;
     }
-    return false;
+    const confidence = this.confidenceModel.calculate({
+      pattern,
+      captured,
+      stemMatchCount: this.stemMatchCount,
+      totalKeywordMatches: this.totalKeywordMatches
+    });
+    this.applyExtractionRules(pattern, captured);
+    return {
+      pattern,
+      captured,
+      consumedTokens: tokens.position() - mark.position,
+      confidence,
+      roleStarts: this.roleStarts,
+      ...this.reader.resultFields?.()
+    };
   }
-  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;
+  /**
+   * Try to match multiple patterns, return the best match.
+   */
+  matchBest(tokens, patterns) {
+    this.matchCache.clear();
+    const matches = [];
+    const startPos = tokens.position();
+    for (const pattern of patterns) {
+      const mark = tokens.mark();
+      const cacheKey = `${startPos}:${pattern.id}`;
+      let result;
+      if (this.matchCache.has(cacheKey)) {
+        result = this.matchCache.get(cacheKey);
+      } else {
+        result = this.matchPattern(tokens, pattern);
+        this.matchCache.set(cacheKey, result);
+      }
+      if (result) {
+        matches.push(result);
+      }
+      tokens.reset(mark);
     }
-  }
-  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);
+    if (matches.length === 0) {
+      return null;
+    }
+    matches.sort((a, b) => {
+      const priorityDiff = b.pattern.priority - a.pattern.priority;
+      if (priorityDiff !== 0) return priorityDiff;
+      return b.confidence - a.confidence;
+    });
+    const best = matches[0];
+    this.matchPattern(tokens, best.pattern);
+    return best;
   }
   /**
-   * Check if logging is enabled for this namespace.
+   * Match a sequence of pattern tokens against the token stream.
    */
-  isEnabled() {
-    return this.enabled;
+  matchTokenSequence(tokens, patternTokens, captured, nextAfterSequence) {
+    this.reader.skipLeading?.(tokens, patternTokens);
+    for (let i = 0; i < patternTokens.length; i++) {
+      const patternToken = patternTokens[i];
+      this.reader.beforePatternToken?.(tokens, patternTokens, i, captured);
+      if (this.reader.maySkipSlot(
+        patternToken,
+        tokens.peek(),
+        patternTokens[i + 1] ?? nextAfterSequence
+      )) {
+        const skipMark = tokens.mark();
+        const speculative = new Map(captured);
+        if (this.matchTokenSequence(
+          tokens,
+          patternTokens.slice(i + 1),
+          speculative,
+          nextAfterSequence
+        ) && this.reader.atClauseEnd(tokens)) {
+          captured.clear();
+          for (const [role, value] of speculative) captured.set(role, value);
+          return true;
+        }
+        tokens.reset(skipMark);
+      }
+      const outerRest = this.patternRest;
+      this.patternRest = [...patternTokens.slice(i + 1), ...outerRest];
+      this.slotAfterLiteral = patternToken.type === "role" && patternTokens[i - 1]?.type === "literal";
+      const matched = this.matchPatternToken(
+        tokens,
+        patternToken,
+        captured,
+        patternTokens[i + 1] ?? nextAfterSequence
+      );
+      this.patternRest = outerRest;
+      if (!matched) {
+        if (this.isOptional(patternToken)) {
+          continue;
+        }
+        return false;
+      }
+    }
+    return true;
   }
   /**
-   * Programmatically enable logging for this namespace.
+   * Match a single pattern token against the current position in the stream.
    */
-  enable() {
-    this.enabled = true;
+  matchPatternToken(tokens, patternToken, captured, nextPatternToken) {
+    switch (patternToken.type) {
+      case "literal":
+        return this.matchLiteralToken(tokens, patternToken);
+      case "role": {
+        const roleStart = tokens.position();
+        const matchedRole = this.reader.readRole(tokens, patternToken, captured, nextPatternToken);
+        if (matchedRole && captured.has(patternToken.role)) {
+          this.roleStarts.set(patternToken.role, roleStart);
+        }
+        return matchedRole;
+      }
+      case "group":
+        return this.matchGroupToken(tokens, patternToken, captured, nextPatternToken);
+      default:
+        return false;
+    }
   }
   /**
-   * Programmatically disable logging for this namespace.
+   * Match a literal pattern token (keyword or particle).
    */
-  disable() {
-    this.enabled = false;
-  }
-};
-function createLogger(namespace) {
-  return new DebugLogger(namespace);
-}
-
-// 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;
+  matchLiteralToken(tokens, patternToken) {
+    const token = tokens.peek();
+    if (!token) return false;
+    const matchType = this.getMatchType(token, patternToken.value);
+    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;
+        }
+      }
+    }
+    for (const value of [patternToken.value, ...patternToken.alternatives ?? []]) {
+      for (const sep of ["-", "_"]) {
+        if (value.includes(sep) && this.tryMatchShatteredCompound(tokens, value, sep)) {
+          this.totalKeywordMatches++;
+          return true;
+        }
+      }
+    }
+    return false;
   }
-  if (expectedTypes.includes("expression")) {
+  /**
+   * Match a compound keyword (`titik-henti`, `по_умолчанию`) against a
+   * shattered token run (`titik` `-` `henti` / `по` `_` `умолчанию`): word
+   * segments must be identifier/keyword/particle tokens equal to the expected
+   * segments (case-insensitive; particle because prepositions like ru `по` /
+   * uk `за` lead some underscore compounds), separators lone `sep` tokens.
+   * Consumes the run on success, resets the stream on failure.
+   */
+  tryMatchShatteredCompound(tokens, expected, sep) {
+    const segments = expected.split(sep);
+    if (segments.length < 2 || segments.some((s) => s.length === 0)) return false;
+    const mark = tokens.mark();
+    for (let i = 0; i < segments.length; i++) {
+      if (i > 0) {
+        const sepToken = tokens.peek();
+        if (!sepToken || sepToken.value !== sep) {
+          tokens.reset(mark);
+          return false;
+        }
+        tokens.advance();
+      }
+      const word = tokens.peek();
+      if (!word || word.kind !== "identifier" && word.kind !== "keyword" && word.kind !== "particle" || word.value.toLowerCase() !== segments[i].toLowerCase()) {
+        tokens.reset(mark);
+        return false;
+      }
+      tokens.advance();
+    }
     return true;
   }
-  if (actualType === "property-path") {
-    return expectedTypes.some((t) => ["selector", "reference", "expression"].includes(t));
-  }
-  return false;
-}
+  /**
+   * Match a group pattern token (optional sequence).
+   */
+  matchGroupToken(tokens, patternToken, captured, nextPatternToken) {
+    const mark = tokens.mark();
+    const capturedBefore = new Map(captured);
+    let success = this.matchTokenSequence(tokens, patternToken.tokens, captured, nextPatternToken);
+    if (success && tokens.position() > mark.position && groupHasRole(patternToken) && [...captured].every(([role, value]) => capturedBefore.get(role) === value) && captured.size === capturedBefore.size) {
+      success = false;
+    }
+    if (success) {
+      const markerLiterals = [];
+      for (const inner of patternToken.tokens) {
+        if (inner.type === "group" && inner.renderRequired) {
+          for (const t of inner.tokens) {
+            if (t.type === "literal") markerLiterals.push(t.value, ...t.alternatives ?? []);
+          }
+        }
+      }
+      if (markerLiterals.length > 0) {
+        const addedRole = [...captured.keys()].some((role) => !capturedBefore.has(role));
+        if (addedRole) {
+          const last = tokens.tokens[tokens.position() - 1];
+          const markerSeen = last !== void 0 && tokens.position() > mark.position && markerLiterals.some((lit) => this.getMatchType(last, lit) !== "none");
+          if (!markerSeen) success = false;
+        }
+      }
+    }
+    if (!success) {
+      tokens.reset(mark);
+      for (const role of captured.keys()) {
+        if (!capturedBefore.has(role)) {
+          captured.delete(role);
+        }
+      }
+      for (const [role, value] of capturedBefore) {
+        if (captured.get(role) !== value) {
+          captured.set(role, value);
+        }
+      }
+      return patternToken.optional || false;
+    }
+    return true;
+  }
+  /**
+   * Whether a pattern token (literal, or a group starting with a literal) would
+   * match the given stream token. Used to keep the event-head source-clause
+   * consumption from stealing a marker the pattern explicitly expects.
+   */
+  patternTokenWouldMatch(pt, token) {
+    if (!pt) return false;
+    if (pt.type === "literal") {
+      if (this.getMatchType(token, pt.value) !== "none") return true;
+      return !!pt.alternatives?.some((a) => this.getMatchType(token, a) !== "none");
+    }
+    if (pt.type === "group") {
+      return this.patternTokenWouldMatch(pt.tokens?.[0], token);
+    }
+    return false;
+  }
+  /**
+   * 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" && token.value.toLowerCase() === value.toLowerCase()) {
+      return "case-insensitive";
+    }
+    if (token.kind === "keyword") {
+      const strippedToken = stripOptionalDiacritics(token.value).toLowerCase();
+      if (strippedToken && strippedToken === stripOptionalDiacritics(value).toLowerCase()) {
+        return "case-insensitive";
+      }
+    }
+    return "none";
+  }
+  /**
+   * Apply extraction rules to fill in static values and defaults for missing
+   * roles, and re-shape captured roles that declare a `transform` (the
+   * ExtractionRule field was documented but unwired — go-qu-url-dest is the
+   * first consumer: it re-types the marker-bound capture to the expression
+   * shape the en reference produces).
+   */
+  applyExtractionRules(pattern, captured) {
+    for (const [role, rule] of Object.entries(pattern.extraction)) {
+      const existing = captured.get(role);
+      if (existing) {
+        if (rule.transform) {
+          const raw = existing.type === "literal" ? String(existing.value) : String(existing.raw ?? "");
+          captured.set(role, rule.transform(raw));
+        }
+      } else if (rule.value !== void 0) {
+        captured.set(
+          role,
+          rule.valueIsExpression ? { type: "expression", raw: rule.value } : { type: "literal", value: rule.value }
+        );
+      } else if (rule.default) {
+        const implicitDefault = {
+          ...rule.default,
+          implicit: true
+        };
+        captured.set(role, implicitDefault);
+      }
+    }
+  }
+  /**
+   * Check if a pattern token is optional.
+   */
+  isOptional(patternToken) {
+    return patternToken.type !== "literal" && patternToken.optional === true;
+  }
+};
+
+// src/core/matching/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;
+}
 function validateValueType(value, expectedTypes) {
   if (!expectedTypes || expectedTypes.length === 0) {
     return true;
@@ -1798,7 +2096,7 @@ function isBuiltInReference(value) {
   return builtIns.has(value.toLowerCase());
 }
 
-// src/core/pattern-matching/utils/possessive-keywords.ts
+// src/core/matching/possessive-keywords.ts
 function getPossessiveReference(profile, keyword) {
   return profile?.possessive?.keywords?.[keyword];
 }
@@ -2143,1076 +2441,61 @@ function tokenToSemanticValue(token) {
       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();
-function matchPattern(tokens, pattern) {
-  return patternMatcher.matchPattern(tokens, pattern);
-}
-function matchBest(tokens, patterns) {
-  return patternMatcher.matchBest(tokens, patterns);
-}
-
-// src/core/matching/match-skeleton.ts
-function groupHasRole(group) {
-  return group.tokens.some((t) => t.type === "role" || t.type === "group" && groupHasRole(t));
-}
-var MatchSkeleton = class {
-  /**
-   * @param makeReader - builds the grammar's reader, handed this matcher's view
-   *   of the match in progress (one reader per matcher).
-   */
-  constructor(makeReader, confidenceModel) {
-    /**
-     * The pattern tokens still to match after the one being matched, through
-     * every enclosing group: a value stops at any marker the pattern still owes.
-     */
-    this.patternRest = [];
-    /**
-     * Whether the role slot being matched directly follows a literal the pattern
-     * matched: its marker (`[por {quantity}]`), or the command's verb.
-     */
-    this.slotAfterLiteral = false;
-    /**
-     * Selective memoization cache (Phase 6.1).
-     * Caches pattern match results keyed by `tokenPosition:patternId`.
-     * Cleared before each top-level matchBest() call.
-     */
-    this.matchCache = /* @__PURE__ */ new Map();
-    /**
-     * Stream index where each role's capture began, for the current
-     * `matchPattern` call. Rebuilt per call, written on the same success path as
-     * `captured` — see `PatternMatchResult.roleStarts`.
-     */
-    this.roleStarts = /* @__PURE__ */ new Map();
-    /**
-     * Track stem matches for confidence calculation.
-     * This is set during matching and read during confidence calculation.
-     */
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-    this.confidenceModel = confidenceModel;
-    this.reader = makeReader({
-      patternRest: () => this.patternRest,
-      slotAfterLiteral: () => this.slotAfterLiteral,
-      wouldMatch: (pt, token) => this.patternTokenWouldMatch(pt, token)
-    });
-  }
-  /**
-   * Try to match a single pattern against the token stream.
-   * Returns the match result or null if no match.
-   */
-  matchPattern(tokens, pattern) {
-    const mark = tokens.mark();
-    const captured = /* @__PURE__ */ new Map();
-    this.reader.beginPattern(pattern);
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-    this.roleStarts = /* @__PURE__ */ new Map();
-    this.patternRest = [];
-    const success = this.matchTokenSequence(tokens, pattern.template.tokens, captured);
-    if (!success) {
-      tokens.reset(mark);
-      return null;
-    }
-    const confidence = this.confidenceModel.calculate({
-      pattern,
-      captured,
-      stemMatchCount: this.stemMatchCount,
-      totalKeywordMatches: this.totalKeywordMatches
-    });
-    this.applyExtractionRules(pattern, captured);
-    return {
-      pattern,
-      captured,
-      consumedTokens: tokens.position() - mark.position,
-      confidence,
-      roleStarts: this.roleStarts,
-      ...this.reader.resultFields?.()
-    };
-  }
-  /**
-   * Try to match multiple patterns, return the best match.
-   */
-  matchBest(tokens, patterns) {
-    this.matchCache.clear();
-    const matches = [];
-    const startPos = tokens.position();
-    for (const pattern of patterns) {
-      const mark = tokens.mark();
-      const cacheKey = `${startPos}:${pattern.id}`;
-      let result;
-      if (this.matchCache.has(cacheKey)) {
-        result = this.matchCache.get(cacheKey);
-      } else {
-        result = this.matchPattern(tokens, pattern);
-        this.matchCache.set(cacheKey, result);
-      }
-      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;
-      return b.confidence - a.confidence;
-    });
-    const best = matches[0];
-    this.matchPattern(tokens, best.pattern);
-    return best;
-  }
-  /**
-   * Match a sequence of pattern tokens against the token stream.
-   */
-  matchTokenSequence(tokens, patternTokens, captured, nextAfterSequence) {
-    this.reader.skipLeading?.(tokens, patternTokens);
-    for (let i = 0; i < patternTokens.length; i++) {
-      const patternToken = patternTokens[i];
-      this.reader.beforePatternToken?.(tokens, patternTokens, i, captured);
-      if (this.reader.maySkipSlot(
-        patternToken,
-        tokens.peek(),
-        patternTokens[i + 1] ?? nextAfterSequence
-      )) {
-        const skipMark = tokens.mark();
-        const speculative = new Map(captured);
-        if (this.matchTokenSequence(
-          tokens,
-          patternTokens.slice(i + 1),
-          speculative,
-          nextAfterSequence
-        ) && this.reader.atClauseEnd(tokens)) {
-          captured.clear();
-          for (const [role, value] of speculative) captured.set(role, value);
-          return true;
-        }
-        tokens.reset(skipMark);
-      }
-      const outerRest = this.patternRest;
-      this.patternRest = [...patternTokens.slice(i + 1), ...outerRest];
-      this.slotAfterLiteral = patternToken.type === "role" && patternTokens[i - 1]?.type === "literal";
-      const matched = this.matchPatternToken(
-        tokens,
-        patternToken,
-        captured,
-        patternTokens[i + 1] ?? nextAfterSequence
-      );
-      this.patternRest = outerRest;
-      if (!matched) {
-        if (this.isOptional(patternToken)) {
-          continue;
-        }
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Match a single pattern token against the current position in the stream.
-   */
-  matchPatternToken(tokens, patternToken, captured, nextPatternToken) {
-    switch (patternToken.type) {
-      case "literal":
-        return this.matchLiteralToken(tokens, patternToken);
-      case "role": {
-        const roleStart = tokens.position();
-        const matchedRole = this.reader.readRole(tokens, patternToken, captured, nextPatternToken);
-        if (matchedRole && captured.has(patternToken.role)) {
-          this.roleStarts.set(patternToken.role, roleStart);
-        }
-        return matchedRole;
-      }
-      case "group":
-        return this.matchGroupToken(tokens, patternToken, captured, nextPatternToken);
-      default:
-        return false;
-    }
-  }
-  /**
-   * Match a literal pattern token (keyword or particle).
-   */
-  matchLiteralToken(tokens, patternToken) {
-    const token = tokens.peek();
-    if (!token) return false;
-    const matchType = this.getMatchType(token, patternToken.value);
-    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;
-        }
-      }
-    }
-    for (const value of [patternToken.value, ...patternToken.alternatives ?? []]) {
-      for (const sep of ["-", "_"]) {
-        if (value.includes(sep) && this.tryMatchShatteredCompound(tokens, value, sep)) {
-          this.totalKeywordMatches++;
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  /**
-   * Match a compound keyword (`titik-henti`, `по_умолчанию`) against a
-   * shattered token run (`titik` `-` `henti` / `по` `_` `умолчанию`): word
-   * segments must be identifier/keyword/particle tokens equal to the expected
-   * segments (case-insensitive; particle because prepositions like ru `по` /
-   * uk `за` lead some underscore compounds), separators lone `sep` tokens.
-   * Consumes the run on success, resets the stream on failure.
-   */
-  tryMatchShatteredCompound(tokens, expected, sep) {
-    const segments = expected.split(sep);
-    if (segments.length < 2 || segments.some((s) => s.length === 0)) return false;
-    const mark = tokens.mark();
-    for (let i = 0; i < segments.length; i++) {
-      if (i > 0) {
-        const sepToken = tokens.peek();
-        if (!sepToken || sepToken.value !== sep) {
-          tokens.reset(mark);
-          return false;
-        }
-        tokens.advance();
-      }
-      const word = tokens.peek();
-      if (!word || word.kind !== "identifier" && word.kind !== "keyword" && word.kind !== "particle" || word.value.toLowerCase() !== segments[i].toLowerCase()) {
-        tokens.reset(mark);
-        return false;
-      }
-      tokens.advance();
-    }
-    return true;
-  }
-  /**
-   * Match a group pattern token (optional sequence).
-   */
-  matchGroupToken(tokens, patternToken, captured, nextPatternToken) {
-    const mark = tokens.mark();
-    const capturedBefore = new Map(captured);
-    let success = this.matchTokenSequence(tokens, patternToken.tokens, captured, nextPatternToken);
-    if (success && tokens.position() > mark.position && groupHasRole(patternToken) && [...captured].every(([role, value]) => capturedBefore.get(role) === value) && captured.size === capturedBefore.size) {
-      success = false;
-    }
-    if (success) {
-      const markerLiterals = [];
-      for (const inner of patternToken.tokens) {
-        if (inner.type === "group" && inner.renderRequired) {
-          for (const t of inner.tokens) {
-            if (t.type === "literal") markerLiterals.push(t.value, ...t.alternatives ?? []);
-          }
-        }
-      }
-      if (markerLiterals.length > 0) {
-        const addedRole = [...captured.keys()].some((role) => !capturedBefore.has(role));
-        if (addedRole) {
-          const last = tokens.tokens[tokens.position() - 1];
-          const markerSeen = last !== void 0 && tokens.position() > mark.position && markerLiterals.some((lit) => this.getMatchType(last, lit) !== "none");
-          if (!markerSeen) success = false;
-        }
-      }
-    }
-    if (!success) {
-      tokens.reset(mark);
-      for (const role of captured.keys()) {
-        if (!capturedBefore.has(role)) {
-          captured.delete(role);
-        }
+      if (typeof token.value === "string" && token.value.startsWith(":")) {
+        return createReference(token.value);
       }
-      for (const [role, value] of capturedBefore) {
-        if (captured.get(role) !== value) {
-          captured.set(role, value);
-        }
+      const identLower = safeToLowerCase(token.value);
+      if (isValidReference(identLower)) {
+        return createReference(identLower);
       }
-      return patternToken.optional || false;
+      return { type: "expression", raw: token.value };
     }
-    return true;
+    case "url":
+      return createLiteral(token.value, "string");
+    default:
+      return null;
   }
-  /**
-   * Whether a pattern token (literal, or a group starting with a literal) would
-   * match the given stream token. Used to keep the event-head source-clause
-   * consumption from stealing a marker the pattern explicitly expects.
-   */
-  patternTokenWouldMatch(pt, token) {
-    if (!pt) return false;
-    if (pt.type === "literal") {
-      if (this.getMatchType(token, pt.value) !== "none") return true;
-      return !!pt.alternatives?.some((a) => this.getMatchType(token, a) !== "none");
-    }
-    if (pt.type === "group") {
-      return this.patternTokenWouldMatch(pt.tokens?.[0], token);
-    }
-    return false;
+}
+function parseLiteralValue(value) {
+  if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
+    const inner = value.slice(1, -1);
+    return createLiteral(inner, "string");
   }
-  /**
-   * 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" && token.value.toLowerCase() === value.toLowerCase()) {
-      return "case-insensitive";
-    }
-    if (token.kind === "keyword") {
-      const strippedToken = stripOptionalDiacritics(token.value).toLowerCase();
-      if (strippedToken && strippedToken === stripOptionalDiacritics(value).toLowerCase()) {
-        return "case-insensitive";
-      }
+  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 "none";
+    return createLiteral(num2, "number");
   }
-  /**
-   * Apply extraction rules to fill in static values and defaults for missing
-   * roles, and re-shape captured roles that declare a `transform` (the
-   * ExtractionRule field was documented but unwired — go-qu-url-dest is the
-   * first consumer: it re-types the marker-bound capture to the expression
-   * shape the en reference produces).
-   */
-  applyExtractionRules(pattern, captured) {
-    for (const [role, rule] of Object.entries(pattern.extraction)) {
-      const existing = captured.get(role);
-      if (existing) {
-        if (rule.transform) {
-          const raw = existing.type === "literal" ? String(existing.value) : String(existing.raw ?? "");
-          captured.set(role, rule.transform(raw));
-        }
-      } else if (rule.value !== void 0) {
-        captured.set(
-          role,
-          rule.valueIsExpression ? { type: "expression", raw: rule.value } : { type: "literal", value: rule.value }
-        );
-      } else if (rule.default) {
-        const implicitDefault = {
-          ...rule.default,
-          implicit: true
-        };
-        captured.set(role, implicitDefault);
-      }
+  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);
   }
-  /**
-   * Check if a pattern token is optional.
-   */
-  isOptional(patternToken) {
-    return patternToken.type !== "literal" && patternToken.optional === true;
+  if (tokenLower === "class") {
+    tokens.advance();
   }
-};
+}
 
 // src/core/matching/stock-reader.ts
 function greedyStopMarkers(rest) {
@@ -3313,6 +2596,144 @@ var StockValueReader = class {
 function createStockReader(profiles = {}) {
   return (view) => new StockValueReader(view, profiles);
 }
+
+// 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)
+};
 export {
   BaseMorphologicalNormalizer,
   BaseTokenizer,
@@ -3320,7 +2741,6 @@ export {
   DEFAULT_PUNCTUATION,
   MatchSkeleton,
   OperatorExtractor,
-  PatternMatcher,
   PunctuationExtractor,
   StockValueReader,
   TokenStreamImpl,
@@ -3374,11 +2794,8 @@ export {
   isUrlStart,
   isVariableRef,
   isWhitespace,
-  matchBest,
-  matchPattern,
   noChange,
   normalized,
-  patternMatcher,
   readGreedy,
   readRoleValue,
   stockConfidenceModel,