@lokascript/framework 4.6.0 → 4.8.0

package/dist/api/index.js

@@ -108,10 +108,535 @@ function getPossessiveReference(profile, keyword) {
   return profile?.possessive?.keywords?.[keyword];
 }
 
-// src/core/pattern-matching/pattern-matcher.ts
+// src/core/matching/stock-reading.ts
 function isValidReference(_value) {
   return false;
 }
+function safeToLowerCase(value) {
+  if (typeof value === "string") {
+    return value.toLowerCase();
+  }
+  if (value === null || value === void 0) {
+    return "";
+  }
+  return String(value).toLowerCase();
+}
+function readRoleValue(tokens, patternToken, captured, profile) {
+  skipNoiseWords(tokens);
+  const token = tokens.peek();
+  if (!token) {
+    return patternToken.optional || false;
+  }
+  const possessiveValue = tryMatchPossessiveExpression(tokens, profile);
+  if (possessiveValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(possessiveValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, possessiveValue);
+    return true;
+  }
+  const methodCallValue = tryMatchMethodCallExpression(tokens);
+  if (methodCallValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(methodCallValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, methodCallValue);
+    return true;
+  }
+  const possessiveSelectorValue = tryMatchPossessiveSelectorExpression(tokens);
+  if (possessiveSelectorValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(possessiveSelectorValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, possessiveSelectorValue);
+    return true;
+  }
+  const propertyAccessValue = tryMatchPropertyAccessExpression(tokens);
+  if (propertyAccessValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(propertyAccessValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, propertyAccessValue);
+    return true;
+  }
+  const selectorPropertyValue = tryMatchSelectorPropertyExpression(tokens);
+  if (selectorPropertyValue) {
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(selectorPropertyValue.type, patternToken.expectedTypes)) {
+        return patternToken.optional || false;
+      }
+    }
+    captured.set(patternToken.role, selectorPropertyValue);
+    return true;
+  }
+  const value = tokenToSemanticValue(token);
+  if (!value) {
+    return patternToken.optional || false;
+  }
+  if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+    if (!isTypeCompatible(value.type, patternToken.expectedTypes)) {
+      return patternToken.optional || false;
+    }
+  }
+  captured.set(patternToken.role, value);
+  tokens.advance();
+  return true;
+}
+function tryMatchPossessiveExpression(tokens, profile) {
+  const token = tokens.peek();
+  if (!token) return null;
+  if (!profile) return null;
+  const tokenValue = token.normalized || token.value;
+  const tokenLower = safeToLowerCase(tokenValue);
+  const baseRef = getPossessiveReference(profile, tokenLower);
+  if (!baseRef) return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken) {
+    tokens.reset(mark);
+    return null;
+  }
+  if (propertyToken.kind === "identifier" || propertyToken.kind === "keyword" && !isStructuralKeyword(propertyToken.value) || propertyToken.kind === "selector" && propertyToken.value.startsWith("*") || propertyToken.kind === "selector" && propertyToken.value.startsWith("@") || propertyToken.kind === "selector" && propertyToken.value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyToken.value)) {
+    tokens.advance();
+    let propertyName = propertyToken.value;
+    if (propertyToken.kind === "selector" && propertyName.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyName)) {
+      propertyName = propertyName.substring(1);
+    }
+    let chainedProps = propertyName;
+    while (tokens.peek()?.kind === "selector" && tokens.peek().value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(tokens.peek().value)) {
+      chainedProps += tokens.peek().value;
+      tokens.advance();
+    }
+    const nextPeek = tokens.peek();
+    if (nextPeek?.kind === "literal" && nextPeek.value.startsWith("(")) {
+      chainedProps += nextPeek.value;
+      tokens.advance();
+    }
+    return createPropertyPath(createReference(baseRef), chainedProps);
+  }
+  tokens.reset(mark);
+  return null;
+}
+function isStructuralKeyword(value) {
+  const structural = /* @__PURE__ */ new Set([
+    // Prepositions
+    "into",
+    "in",
+    "to",
+    "from",
+    "at",
+    "by",
+    "with",
+    "without",
+    "before",
+    "after",
+    "of",
+    "as",
+    "on",
+    // Control flow
+    "then",
+    "end",
+    "else",
+    "if",
+    "repeat",
+    "while",
+    "for",
+    // Commands (shouldn't be property names)
+    "toggle",
+    "add",
+    "remove",
+    "put",
+    "set",
+    "show",
+    "hide",
+    "increment",
+    "decrement",
+    "send",
+    "trigger",
+    "call"
+  ]);
+  return structural.has(value.toLowerCase());
+}
+function tryMatchMethodCallExpression(tokens) {
+  const token = tokens.peek();
+  if (!token || token.kind !== "selector") return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const dotToken = tokens.peek();
+  if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const methodToken = tokens.peek();
+  if (!methodToken || methodToken.kind !== "identifier") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const openParen = tokens.peek();
+  if (!openParen || openParen.kind !== "punctuation" || openParen.value !== "(") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const args = [];
+  while (!tokens.isAtEnd() && args.length < MAX_METHOD_ARGS) {
+    const argToken = tokens.peek();
+    if (!argToken) break;
+    if (argToken.kind === "punctuation" && argToken.value === ")") {
+      tokens.advance();
+      break;
+    }
+    if (argToken.kind === "punctuation" && argToken.value === ",") {
+      tokens.advance();
+      continue;
+    }
+    args.push(argToken.value);
+    tokens.advance();
+  }
+  const methodCall = `${token.value}.${methodToken.value}(${args.join(", ")})`;
+  return {
+    type: "expression",
+    raw: methodCall
+  };
+}
+function tryMatchPropertyAccessExpression(tokens) {
+  const token = tokens.peek();
+  if (!token) return null;
+  if (token.kind !== "identifier" && token.kind !== "keyword") return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const dotToken = tokens.peek();
+  if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken || propertyToken.kind !== "identifier") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  let chain = `${token.value}.${propertyToken.value}`;
+  let depth = 1;
+  while (!tokens.isAtEnd() && depth < MAX_PROPERTY_DEPTH) {
+    const nextDot = tokens.peek();
+    if (!nextDot || nextDot.kind !== "operator" || nextDot.value !== ".") {
+      break;
+    }
+    tokens.advance();
+    const nextProp = tokens.peek();
+    if (!nextProp || nextProp.kind !== "identifier") {
+      break;
+    }
+    tokens.advance();
+    chain += `.${nextProp.value}`;
+    depth++;
+  }
+  const openParen = tokens.peek();
+  if (openParen && openParen.kind === "punctuation" && openParen.value === "(") {
+    tokens.advance();
+    const args = [];
+    let argDepth = 0;
+    while (!tokens.isAtEnd() && args.length < MAX_METHOD_ARGS) {
+      const argToken = tokens.peek();
+      if (!argToken) break;
+      if (argToken.kind === "punctuation" && argToken.value === ")") {
+        if (argDepth === 0) {
+          tokens.advance();
+          break;
+        }
+        argDepth--;
+      }
+      if (argToken.kind === "punctuation" && argToken.value === "(") {
+        argDepth++;
+      }
+      if (argToken.kind === "punctuation" && argToken.value === ",") {
+        tokens.advance();
+        continue;
+      }
+      args.push(argToken.value);
+      tokens.advance();
+    }
+    const methodCall = `${chain}(${args.join(", ")})`;
+    return {
+      type: "expression",
+      raw: methodCall
+    };
+  }
+  return {
+    type: "expression",
+    raw: chain
+  };
+}
+function tryMatchPossessiveSelectorExpression(tokens) {
+  const token = tokens.peek();
+  if (!token || token.kind !== "selector") return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const possessiveToken = tokens.peek();
+  if (!possessiveToken || possessiveToken.kind !== "punctuation" || possessiveToken.value !== "'s") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken) {
+    tokens.reset(mark);
+    return null;
+  }
+  if (propertyToken.kind !== "selector" && propertyToken.kind !== "identifier") {
+    tokens.reset(mark);
+    return null;
+  }
+  tokens.advance();
+  return createPropertyPath(createSelector(token.value), propertyToken.value);
+}
+function tryMatchSelectorPropertyExpression(tokens) {
+  const token = tokens.peek();
+  if (!token || token.kind !== "selector") return null;
+  if (typeof token.value !== "string" || !token.value.startsWith("#")) return null;
+  const mark = tokens.mark();
+  tokens.advance();
+  const propertyToken = tokens.peek();
+  if (!propertyToken || propertyToken.kind !== "selector") {
+    tokens.reset(mark);
+    return null;
+  }
+  if (!propertyToken.value.startsWith(".")) {
+    tokens.reset(mark);
+    return null;
+  }
+  const peek2 = tokens.peek(1);
+  if (peek2 && peek2.kind === "selector") {
+  }
+  tokens.advance();
+  const propertyName = propertyToken.value.slice(1);
+  return createPropertyPath(createSelector(token.value), propertyName);
+}
+var MAX_PROPERTY_DEPTH = 10;
+var MAX_METHOD_ARGS = 20;
+function tokenToSemanticValue(token) {
+  switch (token.kind) {
+    case "selector":
+      return createSelector(token.value);
+    case "literal":
+      return parseLiteralValue(token.value);
+    case "keyword": {
+      const tokenValue = token.normalized || token.value;
+      const lower = safeToLowerCase(tokenValue);
+      if (isValidReference(lower)) {
+        return createReference(lower);
+      }
+      return createLiteral(token.normalized || token.value);
+    }
+    case "identifier": {
+      if (typeof token.value === "string" && token.value.startsWith(":")) {
+        return createReference(token.value);
+      }
+      const identLower = safeToLowerCase(token.value);
+      if (isValidReference(identLower)) {
+        return createReference(identLower);
+      }
+      return { type: "expression", raw: token.value };
+    }
+    case "url":
+      return createLiteral(token.value, "string");
+    default:
+      return null;
+  }
+}
+function parseLiteralValue(value) {
+  if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
+    const inner = value.slice(1, -1);
+    return createLiteral(inner, "string");
+  }
+  if (value === "true") return createLiteral(true, "boolean");
+  if (value === "false") return createLiteral(false, "boolean");
+  const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (durationMatch) {
+    const num2 = parseFloat(durationMatch[1]);
+    const unit = durationMatch[2];
+    if (unit) {
+      return createLiteral(value, "duration");
+    }
+    return createLiteral(num2, "number");
+  }
+  const num = parseFloat(value);
+  if (!isNaN(num)) {
+    return createLiteral(num, "number");
+  }
+  return createLiteral(value, "string");
+}
+var ENGLISH_NOISE_WORDS = /* @__PURE__ */ new Set(["the", "a", "an"]);
+function skipNoiseWords(tokens) {
+  const token = tokens.peek();
+  if (!token) return;
+  const tokenLower = safeToLowerCase(token.value);
+  if (ENGLISH_NOISE_WORDS.has(tokenLower)) {
+    const mark = tokens.mark();
+    tokens.advance();
+    const nextToken = tokens.peek();
+    if (nextToken && nextToken.kind === "selector") {
+      return;
+    }
+    tokens.reset(mark);
+  }
+  if (tokenLower === "class") {
+    tokens.advance();
+  }
+}
+
+// src/core/matching/stock-confidence.ts
+function scoreParts(ctx) {
+  const { pattern, captured } = ctx;
+  let score = 0;
+  let maxScore = 0;
+  const hasDefault = (role) => {
+    return pattern.extraction?.[role]?.default !== void 0;
+  };
+  for (const token of pattern.template.tokens) {
+    if (token.type === "role") {
+      maxScore += 1;
+      if (captured.has(token.role)) {
+        score += 1;
+      }
+    } else if (token.type === "group") {
+      for (const subToken of token.tokens) {
+        if (subToken.type === "role") {
+          const roleHasDefault = hasDefault(subToken.role);
+          const weight = 0.8;
+          maxScore += weight;
+          if (captured.has(subToken.role)) {
+            score += weight;
+          } else if (roleHasDefault) {
+            score += weight * 0.6;
+          }
+        }
+      }
+    }
+  }
+  const roleCoverage = maxScore > 0 ? score / maxScore : 1;
+  let baseConfidence = roleCoverage;
+  let stemPenalty = 0;
+  if (ctx.stemMatchCount > 0 && ctx.totalKeywordMatches > 0) {
+    stemPenalty = ctx.stemMatchCount / ctx.totalKeywordMatches * 0.15;
+    baseConfidence = Math.max(0.5, baseConfidence - stemPenalty);
+  }
+  const vsoBoost = calculateVSOConfidenceBoost(pattern);
+  baseConfidence = Math.min(1, baseConfidence + vsoBoost);
+  const prepositionAdjustment = arabicPrepositionDisambiguation(pattern, captured);
+  baseConfidence = Math.max(0, Math.min(1, baseConfidence + prepositionAdjustment));
+  return {
+    roleCoverage,
+    stemPenalty,
+    languageBoost: vsoBoost,
+    languageAdjustment: prepositionAdjustment,
+    final: baseConfidence
+  };
+}
+function calculateVSOConfidenceBoost(pattern) {
+  if (pattern.language !== "ar") {
+    return 0;
+  }
+  const firstToken = pattern.template.tokens[0];
+  if (!firstToken || firstToken.type !== "literal") {
+    return 0;
+  }
+  const ARABIC_VERBS = /* @__PURE__ */ new Set([
+    "\u0628\u062F\u0644",
+    "\u063A\u064A\u0631",
+    "\u0623\u0636\u0641",
+    "\u0623\u0632\u0644",
+    "\u0636\u0639",
+    "\u0627\u062C\u0639\u0644",
+    "\u0639\u064A\u0646",
+    "\u0632\u062F",
+    "\u0627\u0646\u0642\u0635",
+    "\u0633\u062C\u0644",
+    "\u0623\u0638\u0647\u0631",
+    "\u0623\u062E\u0641",
+    "\u0634\u063A\u0644",
+    "\u0623\u0631\u0633\u0644",
+    "\u0631\u0643\u0632",
+    "\u0634\u0648\u0634",
+    "\u062A\u0648\u0642\u0641",
+    "\u0627\u0646\u0633\u062E",
+    "\u0627\u062D\u0630\u0641",
+    "\u0627\u0635\u0646\u0639",
+    "\u0627\u0646\u062A\u0638\u0631",
+    "\u0627\u0646\u062A\u0642\u0627\u0644",
+    "\u0623\u0648"
+  ]);
+  if (ARABIC_VERBS.has(firstToken.value)) {
+    return 0.15;
+  }
+  if (firstToken.alternatives) {
+    for (const alt of firstToken.alternatives) {
+      if (ARABIC_VERBS.has(alt)) {
+        return 0.15;
+      }
+    }
+  }
+  return 0;
+}
+function arabicPrepositionDisambiguation(pattern, captured) {
+  if (pattern.language !== "ar") {
+    return 0;
+  }
+  let adjustment = 0;
+  const PREFERRED_PREPOSITIONS = {
+    patient: ["\u0639\u0644\u0649"],
+    // element selectors prefer على (on/upon)
+    destination: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
+    // destination prefers إلى (to)
+    source: ["\u0645\u0646"],
+    // source prefers من (from)
+    agent: ["\u0645\u0646"],
+    // agent/by prefers من (from/by)
+    manner: ["\u0628"],
+    // manner prefers ب (with/by)
+    style: ["\u0628"],
+    // style prefers ب (with)
+    goal: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
+    // target state prefers إلى (to)
+    method: ["\u0628"]
+    // method prefers ب (with/by)
+  };
+  for (const [role, value] of captured.entries()) {
+    const preferred = PREFERRED_PREPOSITIONS[role];
+    if (!preferred || preferred.length === 0) {
+      continue;
+    }
+    const metadata = "metadata" in value ? value.metadata : void 0;
+    if (metadata && typeof metadata.prepositionValue === "string") {
+      const usedPreposition = metadata.prepositionValue;
+      if (preferred.includes(usedPreposition)) {
+        adjustment += 0.1;
+      } else {
+        adjustment -= 0.1;
+      }
+    }
+  }
+  return Math.max(-0.1, Math.min(0.1, adjustment));
+}
+var stockConfidenceModel = {
+  calculate: (ctx) => scoreParts(ctx).final,
+  calculateWithBreakdown: (ctx) => scoreParts(ctx)
+};
+
+// src/core/pattern-matching/pattern-matcher.ts
 var _PatternMatcher = class _PatternMatcher {
   constructor() {
     /** Debug logger */
@@ -123,19 +648,6 @@ var _PatternMatcher = class _PatternMatcher {
     this.stemMatchCount = 0;
     this.totalKeywordMatches = 0;
   }
-  /**
-   * Safely convert a value to lowercase string.
-   * Provides protection against non-string values at runtime.
-   */
-  safeToLowerCase(value) {
-    if (typeof value === "string") {
-      return value.toLowerCase();
-    }
-    if (value === null || value === void 0) {
-      return "";
-    }
-    return String(value).toLowerCase();
-  }
   /**
    * Try to match a single pattern against the token stream.
    * Returns the match result or null if no match.
@@ -184,7 +696,12 @@ var _PatternMatcher = class _PatternMatcher {
       tokens.reset(mark);
       return null;
     }
-    const confidence = this.calculateConfidence(pattern, captured);
+    const confidence = stockConfidenceModel.calculate({
+      pattern,
+      captured,
+      stemMatchCount: this.stemMatchCount,
+      totalKeywordMatches: this.totalKeywordMatches
+    });
     this.applyExtractionRules(pattern, captured);
     return {
       pattern,
@@ -369,7 +886,7 @@ var _PatternMatcher = class _PatternMatcher {
       case "literal":
         return this.matchLiteralToken(tokens, patternToken);
       case "role":
-        return this.matchRoleToken(tokens, patternToken, captured);
+        return readRoleValue(tokens, patternToken, captured, this.currentProfile);
       case "group":
         return this.matchGroupToken(tokens, patternToken, captured);
       default:
@@ -427,420 +944,54 @@ var _PatternMatcher = class _PatternMatcher {
     return false;
   }
   /**
-   * Match a role pattern token (captures a semantic value).
-   * Handles multi-token expressions like:
-   * - 'my value' (possessive keyword + property)
-   * - '#dialog.showModal()' (method call)
-   * - "#element's *opacity" (possessive selector + property)
+   * 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.
    */
-  matchRoleToken(tokens, patternToken, captured) {
-    this.logger.debug("    >>> matchRoleToken ENTRY: capturing role", patternToken.role);
-    this.logger.debug("    >>> matchRoleToken: expected types", patternToken.expectedTypes);
-    this.logger.debug("    >>> matchRoleToken: optional?", patternToken.optional);
-    this.skipNoiseWords(tokens);
-    const token = tokens.peek();
-    this.logger.debug(
-      "    >>> After skipNoiseWords, current token:",
-      token ? JSON.stringify({ value: token.value, kind: token.kind }) : "null"
+  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 (!token) {
-      return patternToken.optional || false;
-    }
-    const possessiveValue = this.tryMatchPossessiveExpression(tokens);
-    if (possessiveValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(possessiveValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, possessiveValue);
-      return true;
-    }
-    const methodCallValue = this.tryMatchMethodCallExpression(tokens);
-    if (methodCallValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(methodCallValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, methodCallValue);
-      return true;
-    }
-    const possessiveSelectorValue = this.tryMatchPossessiveSelectorExpression(tokens);
-    if (possessiveSelectorValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(possessiveSelectorValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, possessiveSelectorValue);
-      return true;
-    }
-    const propertyAccessValue = this.tryMatchPropertyAccessExpression(tokens);
-    if (propertyAccessValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(propertyAccessValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, propertyAccessValue);
-      return true;
+    if (success) return true;
+    tokens.reset(mark);
+    for (const role of captured.keys()) {
+      if (!capturedBefore.has(role)) captured.delete(role);
     }
-    const selectorPropertyValue = this.tryMatchSelectorPropertyExpression(tokens);
-    if (selectorPropertyValue) {
-      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!isTypeCompatible(selectorPropertyValue.type, patternToken.expectedTypes)) {
-          return patternToken.optional || false;
-        }
-      }
-      captured.set(patternToken.role, selectorPropertyValue);
-      return true;
-    }
-    this.logger.debug(
-      "    >>> Trying tokenToSemanticValue for token:",
-      token ? JSON.stringify({ value: token.value, kind: token.kind }) : "null"
-    );
-    const value = this.tokenToSemanticValue(token);
-    this.logger.debug(
-      "    >>> tokenToSemanticValue returned:",
-      value ? JSON.stringify(value) : "null"
-    );
-    if (!value) {
-      return patternToken.optional || false;
-    }
-    this.logger.debug(
-      "    >>> Validating type:",
-      value.type,
-      "against expected:",
-      patternToken.expectedTypes
-    );
-    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-      if (!isTypeCompatible(value.type, patternToken.expectedTypes)) {
-        this.logger.debug("    >>> TYPE MISMATCH - returning", patternToken.optional || false);
-        return patternToken.optional || false;
-      }
-    }
-    this.logger.debug("    >>> Type validation PASSED");
-    captured.set(patternToken.role, value);
-    tokens.advance();
-    return true;
-  }
-  /**
-   * Try to match a possessive expression like 'my value' or 'its innerHTML'.
-   * Returns the PropertyPathValue if matched, or null if not.
-   */
-  tryMatchPossessiveExpression(tokens) {
-    const token = tokens.peek();
-    if (!token) return null;
-    if (!this.currentProfile) return null;
-    const tokenValue = token.normalized || token.value;
-    const tokenLower = this.safeToLowerCase(tokenValue);
-    const baseRef = getPossessiveReference(this.currentProfile, tokenLower);
-    if (!baseRef) return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken) {
-      tokens.reset(mark);
-      return null;
-    }
-    if (propertyToken.kind === "identifier" || propertyToken.kind === "keyword" && !this.isStructuralKeyword(propertyToken.value) || propertyToken.kind === "selector" && propertyToken.value.startsWith("*") || propertyToken.kind === "selector" && propertyToken.value.startsWith("@") || propertyToken.kind === "selector" && propertyToken.value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyToken.value)) {
-      tokens.advance();
-      let propertyName = propertyToken.value;
-      if (propertyToken.kind === "selector" && propertyName.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyName)) {
-        propertyName = propertyName.substring(1);
-      }
-      let chainedProps = propertyName;
-      while (tokens.peek()?.kind === "selector" && tokens.peek().value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(tokens.peek().value)) {
-        chainedProps += tokens.peek().value;
-        tokens.advance();
-      }
-      const nextPeek = tokens.peek();
-      if (nextPeek?.kind === "literal" && nextPeek.value.startsWith("(")) {
-        chainedProps += nextPeek.value;
-        tokens.advance();
-      }
-      return createPropertyPath(createReference(baseRef), chainedProps);
-    }
-    tokens.reset(mark);
-    return null;
-  }
-  /**
-   * Check if a keyword is a structural keyword (preposition, control flow, etc.)
-   * that shouldn't be consumed as a property name.
-   */
-  isStructuralKeyword(value) {
-    const structural = /* @__PURE__ */ new Set([
-      // Prepositions
-      "into",
-      "in",
-      "to",
-      "from",
-      "at",
-      "by",
-      "with",
-      "without",
-      "before",
-      "after",
-      "of",
-      "as",
-      "on",
-      // Control flow
-      "then",
-      "end",
-      "else",
-      "if",
-      "repeat",
-      "while",
-      "for",
-      // Commands (shouldn't be property names)
-      "toggle",
-      "add",
-      "remove",
-      "put",
-      "set",
-      "show",
-      "hide",
-      "increment",
-      "decrement",
-      "send",
-      "trigger",
-      "call"
-    ]);
-    return structural.has(value.toLowerCase());
-  }
-  /**
-   * Try to match a method call expression like '#dialog.showModal()'.
-   * Pattern: selector + '.' + identifier + '(' + [args] + ')'
-   * Returns an expression value if matched, or null if not.
-   */
-  tryMatchMethodCallExpression(tokens) {
-    const token = tokens.peek();
-    if (!token || token.kind !== "selector") return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const dotToken = tokens.peek();
-    if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const methodToken = tokens.peek();
-    if (!methodToken || methodToken.kind !== "identifier") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const openParen = tokens.peek();
-    if (!openParen || openParen.kind !== "punctuation" || openParen.value !== "(") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const args = [];
-    while (!tokens.isAtEnd() && args.length < _PatternMatcher.MAX_METHOD_ARGS) {
-      const argToken = tokens.peek();
-      if (!argToken) break;
-      if (argToken.kind === "punctuation" && argToken.value === ")") {
-        tokens.advance();
-        break;
-      }
-      if (argToken.kind === "punctuation" && argToken.value === ",") {
-        tokens.advance();
-        continue;
-      }
-      args.push(argToken.value);
-      tokens.advance();
-    }
-    const methodCall = `${token.value}.${methodToken.value}(${args.join(", ")})`;
-    return {
-      type: "expression",
-      raw: methodCall
-    };
-  }
-  /**
-   * Try to match a property access expression like 'userData.name' or 'it.data'.
-   * Pattern: (identifier | keyword) + '.' + identifier [+ '.' + identifier ...]
-   * Returns an expression value if matched, or null if not.
-   */
-  tryMatchPropertyAccessExpression(tokens) {
-    const token = tokens.peek();
-    if (!token) return null;
-    if (token.kind !== "identifier" && token.kind !== "keyword") return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const dotToken = tokens.peek();
-    if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken || propertyToken.kind !== "identifier") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    let chain = `${token.value}.${propertyToken.value}`;
-    let depth = 1;
-    while (!tokens.isAtEnd() && depth < _PatternMatcher.MAX_PROPERTY_DEPTH) {
-      const nextDot = tokens.peek();
-      if (!nextDot || nextDot.kind !== "operator" || nextDot.value !== ".") {
-        break;
-      }
-      tokens.advance();
-      const nextProp = tokens.peek();
-      if (!nextProp || nextProp.kind !== "identifier") {
-        break;
-      }
-      tokens.advance();
-      chain += `.${nextProp.value}`;
-      depth++;
-    }
-    const openParen = tokens.peek();
-    if (openParen && openParen.kind === "punctuation" && openParen.value === "(") {
-      tokens.advance();
-      const args = [];
-      let argDepth = 0;
-      while (!tokens.isAtEnd() && args.length < _PatternMatcher.MAX_METHOD_ARGS) {
-        const argToken = tokens.peek();
-        if (!argToken) break;
-        if (argToken.kind === "punctuation" && argToken.value === ")") {
-          if (argDepth === 0) {
-            tokens.advance();
-            break;
-          }
-          argDepth--;
-        }
-        if (argToken.kind === "punctuation" && argToken.value === "(") {
-          argDepth++;
-        }
-        if (argToken.kind === "punctuation" && argToken.value === ",") {
-          tokens.advance();
-          continue;
-        }
-        args.push(argToken.value);
-        tokens.advance();
-      }
-      const methodCall = `${chain}(${args.join(", ")})`;
-      return {
-        type: "expression",
-        raw: methodCall
-      };
-    }
-    return {
-      type: "expression",
-      raw: chain
-    };
-  }
-  /**
-   * Try to match a possessive selector expression like "#element's *opacity".
-   * Pattern: selector + "'s" + (selector | identifier)
-   * Returns a property-path value if matched, or null if not.
-   */
-  tryMatchPossessiveSelectorExpression(tokens) {
-    const token = tokens.peek();
-    if (!token || token.kind !== "selector") return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const possessiveToken = tokens.peek();
-    if (!possessiveToken || possessiveToken.kind !== "punctuation" || possessiveToken.value !== "'s") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken) {
-      tokens.reset(mark);
-      return null;
-    }
-    if (propertyToken.kind !== "selector" && propertyToken.kind !== "identifier") {
-      tokens.reset(mark);
-      return null;
-    }
-    tokens.advance();
-    return createPropertyPath(createSelector(token.value), propertyToken.value);
-  }
-  /**
-   * Try to match a selector + property expression like "#output.innerText".
-   * This handles cases where the tokenizer produces two selector tokens:
-   * - #output (id selector)
-   * - .innerText (looks like class selector, but is actually property)
-   *
-   * Pattern: id-selector + class-selector-that-is-actually-property
-   * Returns a property-path value if matched, or null if not.
-   */
-  tryMatchSelectorPropertyExpression(tokens) {
-    const token = tokens.peek();
-    if (!token || token.kind !== "selector") return null;
-    if (typeof token.value !== "string" || !token.value.startsWith("#")) return null;
-    const mark = tokens.mark();
-    tokens.advance();
-    const propertyToken = tokens.peek();
-    if (!propertyToken || propertyToken.kind !== "selector") {
-      tokens.reset(mark);
-      return null;
-    }
-    if (!propertyToken.value.startsWith(".")) {
-      tokens.reset(mark);
-      return null;
-    }
-    const peek2 = tokens.peek(1);
-    if (peek2 && peek2.kind === "selector") {
-    }
-    tokens.advance();
-    const propertyName = propertyToken.value.slice(1);
-    return createPropertyPath(createSelector(token.value), propertyName);
-  }
-  /**
-   * Match a group pattern token (optional sequence).
-   * When the group's leading marker isn't at the current position, scans ahead
-   * 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;
+    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;
         }
       }
     }
@@ -867,7 +1018,7 @@ var _PatternMatcher = class _PatternMatcher {
     if (token.stem === value && token.stemConfidence !== void 0 && token.stemConfidence >= 0.7) {
       return "stem";
     }
-    if (token.kind === "keyword" && this.safeToLowerCase(token.value) === value.toLowerCase()) {
+    if (token.kind === "keyword" && safeToLowerCase(token.value) === value.toLowerCase()) {
       return "case-insensitive";
     }
     return "none";
@@ -915,62 +1066,9 @@ var _PatternMatcher = class _PatternMatcher {
     if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
     return false;
   }
-  /**
-   * Convert a language token to a semantic value.
-   */
-  tokenToSemanticValue(token) {
-    switch (token.kind) {
-      case "selector":
-        return createSelector(token.value);
-      case "literal":
-        return this.parseLiteralValue(token.value);
-      case "keyword":
-        const tokenValue = token.normalized || token.value;
-        const lower = this.safeToLowerCase(tokenValue);
-        if (isValidReference(lower)) {
-          return createReference(lower);
-        }
-        return createLiteral(token.normalized || token.value);
-      case "identifier":
-        if (typeof token.value === "string" && token.value.startsWith(":")) {
-          return createReference(token.value);
-        }
-        const identLower = this.safeToLowerCase(token.value);
-        if (isValidReference(identLower)) {
-          return createReference(identLower);
-        }
-        return { type: "expression", raw: token.value };
-      case "url":
-        return createLiteral(token.value, "string");
-      default:
-        return null;
-    }
-  }
-  /**
-   * Parse a literal value (string, number, boolean).
-   */
-  parseLiteralValue(value) {
-    if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
-      const inner = value.slice(1, -1);
-      return createLiteral(inner, "string");
-    }
-    if (value === "true") return createLiteral(true, "boolean");
-    if (value === "false") return createLiteral(false, "boolean");
-    const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
-    if (durationMatch) {
-      const num2 = parseFloat(durationMatch[1]);
-      const unit = durationMatch[2];
-      if (unit) {
-        return createLiteral(value, "duration");
-      }
-      return createLiteral(num2, "number");
-    }
-    const num = parseFloat(value);
-    if (!isNaN(num)) {
-      return createLiteral(num, "number");
-    }
-    return createLiteral(value, "string");
-  }
+  // ==========================================================================
+  // Depth Limits for Expression Parsing (security hardening)
+  // ==========================================================================
   /**
    * Apply extraction rules to fill in static values and defaults for missing roles.
    */
@@ -991,255 +1089,528 @@ var _PatternMatcher = class _PatternMatcher {
   isOptional(patternToken) {
     return patternToken.type !== "literal" && patternToken.optional === true;
   }
+  // ===========================================================================
+  // English Idiom Support - Noise Word Handling
+  // ===========================================================================
   /**
-   * Calculate confidence score for a match (0-1).
-   *
-   * Confidence is reduced for:
-   * - Stem matches (morphological normalization has inherent uncertainty)
-   * - Missing optional roles (but less penalty if role has a default value)
+   * Extract event modifiers from the token stream.
+   * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
+   * that can appear after event names.
    *
-   * Confidence is increased for:
-   * - VSO languages (Arabic) when pattern starts with a verb
+   * Returns EventModifiers object or undefined if no modifiers found.
    */
-  calculateConfidence(pattern, captured) {
-    let score = 0;
-    let maxScore = 0;
-    const hasDefault = (role) => {
-      return pattern.extraction?.[role]?.default !== void 0;
+  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/core/tokenization/token-utils.ts
+function stripOptionalDiacritics(word) {
+  return word.replace(/[\u064b-\u0652\u0670]/g, "");
+}
+
+// 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?.()
     };
-    for (const token of pattern.template.tokens) {
-      if (token.type === "role") {
-        maxScore += 1;
-        if (captured.has(token.role)) {
-          score += 1;
+  }
+  /**
+   * 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;
         }
-      } 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;
-            }
-          }
+        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;
       }
     }
-    let baseConfidence = maxScore > 0 ? score / maxScore : 1;
-    if (this.stemMatchCount > 0 && this.totalKeywordMatches > 0) {
-      const stemPenalty = this.stemMatchCount / this.totalKeywordMatches * 0.15;
-      baseConfidence = Math.max(0.5, baseConfidence - stemPenalty);
-    }
-    const vsoBoost = this.calculateVSOConfidenceBoost(pattern);
-    baseConfidence = Math.min(1, baseConfidence + vsoBoost);
-    const prepositionAdjustment = this.arabicPrepositionDisambiguation(pattern, captured);
-    baseConfidence = Math.max(0, Math.min(1, baseConfidence + prepositionAdjustment));
-    return baseConfidence;
+    return true;
   }
   /**
-   * Calculate confidence boost for VSO (Verb-Subject-Object) language patterns.
-   * Arabic naturally uses VSO word order, so patterns that start with a verb
-   * should receive a confidence boost.
-   *
-   * Returns +0.15 confidence boost if:
-   * - Language is Arabic ('ar')
-   * - Pattern's first token is a verb keyword
-   *
-   * @param pattern The language pattern being matched
-   * @returns Confidence boost (0 or 0.15)
+   * Match a single pattern token against the current position in the stream.
    */
-  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;
+  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;
     }
-    return 0;
   }
   /**
-   * Arabic preposition disambiguation for confidence adjustment.
-   *
-   * Different Arabic prepositions are more or less natural for different semantic roles:
-   * - على (on/upon) is preferred for patient/target roles (element selectors)
-   * - إلى (to) is preferred for destination roles
-   * - من (from) is preferred for source roles
-   * - في (in) is preferred for location roles
-   *
-   * This method analyzes the prepositions used with captured semantic roles and
-   * adjusts confidence based on idiomaticity:
-   * - +0.10 for highly idiomatic preposition choices
-   * - -0.10 for less natural preposition choices
-   *
-   * @param pattern The language pattern being matched
-   * @param captured The captured semantic values
-   * @returns Confidence adjustment (-0.10 to +0.10)
+   * Match a literal pattern token (keyword or particle).
    */
-  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;
+  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++;
       }
-      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;
+      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 Math.max(-0.1, Math.min(0.1, adjustment));
+    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;
   }
   /**
-   * Skip noise words like "the" before selectors.
-   * This enables more natural English syntax like "toggle the .active".
+   * 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.
    */
-  skipNoiseWords(tokens) {
-    const token = tokens.peek();
-    if (!token) return;
-    const tokenLower = this.safeToLowerCase(token.value);
-    if (_PatternMatcher.ENGLISH_NOISE_WORDS.has(tokenLower)) {
-      const mark = tokens.mark();
+  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();
-      const nextToken = tokens.peek();
-      if (nextToken && nextToken.kind === "selector") {
-        return;
+    }
+    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);
+        }
+      }
+      for (const [role, value] of capturedBefore) {
+        if (captured.get(role) !== value) {
+          captured.set(role, value);
+        }
+      }
+      return patternToken.optional || false;
     }
-    if (tokenLower === "class") {
-      tokens.advance();
+    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;
   }
   /**
-   * 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.
+   * Get the type of match for a token against a value.
+   * Used for confidence calculation.
    */
-  extractEventModifiers(tokens) {
-    const modifiers = {};
-    let foundModifier = false;
-    while (!tokens.isAtEnd()) {
-      const token = tokens.peek();
-      if (!token || token.kind !== "event-modifier") {
-        break;
+  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";
       }
-      const metadata = token.metadata;
-      if (!metadata) {
-        break;
+    }
+    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/stock-reader.ts
+function greedyStopMarkers(rest) {
+  const markers = /* @__PURE__ */ new Set();
+  const add = (pt) => {
+    markers.add(pt.value.toLowerCase());
+    for (const alt of pt.alternatives ?? []) markers.add(alt.toLowerCase());
+  };
+  for (const pt of rest) {
+    if (pt.type === "literal") {
+      add(pt);
+      break;
+    }
+    if (pt.type === "group") {
+      const lead = pt.tokens.find((t) => t.type === "literal");
+      if (lead?.type === "literal") add(lead);
+      if (!pt.optional) break;
+    }
+  }
+  return markers;
+}
+function isStopMarker(token, stopMarkers) {
+  if (stopMarkers.size === 0) return false;
+  if (stopMarkers.has(token.value.toLowerCase())) return true;
+  return !!token.normalized && stopMarkers.has(token.normalized.toLowerCase());
+}
+function readGreedy(tokens, stopMarkers) {
+  const values = [];
+  while (!tokens.isAtEnd()) {
+    const next = tokens.peek();
+    if (!next || isStopMarker(next, stopMarkers)) break;
+    values.push(next.value);
+    tokens.advance();
+  }
+  return values.length > 0 ? { type: "expression", raw: values.join(" ") } : null;
+}
+function isListedWord(token, words) {
+  if (!token) return false;
+  const forms = [token.value, token.normalized].filter((f) => typeof f === "string");
+  return forms.some((form) => words.some((word) => word.toLowerCase() === form.toLowerCase()));
+}
+var StockValueReader = class {
+  constructor(view, profiles = {}) {
+    this.view = view;
+    this.profiles = profiles;
+  }
+  beginPattern(pattern) {
+    this.profile = this.profiles[pattern.language] ?? { code: pattern.language };
+    this.lastOptional = void 0;
+  }
+  readRole(tokens, slot, captured, next) {
+    const start = tokens.mark();
+    if (this.readOnce(tokens, slot, captured, next, true)) {
+      if (!slot.optional) {
+        this.lastOptional = void 0;
+      } else if (captured.has(slot.role) && tokens.position() > start.position && !this.view.slotAfterLiteral() && next?.type !== "literal") {
+        this.lastOptional = { role: slot.role, start, end: tokens.position() };
       }
-      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;
+      return true;
+    }
+    const before = this.lastOptional;
+    if (slot.optional || !before || before.end !== tokens.position()) return false;
+    this.lastOptional = void 0;
+    tokens.reset(before.start);
+    captured.delete(before.role);
+    return this.readOnce(tokens, slot, captured, next, false);
+  }
+  /** One read of `slot`; `guard` refuses a required slot the marker the pattern wants next. */
+  readOnce(tokens, slot, captured, next, guard) {
+    if (guard && !slot.optional && next?.type === "literal") {
+      const token = tokens.peek();
+      if (token && this.view.wouldMatch(next, token)) return false;
+    }
+    if (slot.words && !isListedWord(tokens.peek(), slot.words)) return slot.optional ?? false;
+    if (slot.optional && !slot.greedy) {
+      const token = tokens.peek();
+      if (token && isStopMarker(token, greedyStopMarkers(this.view.patternRest()))) return true;
+    }
+    if (slot.greedy) {
+      const value = readGreedy(tokens, greedyStopMarkers(this.view.patternRest()));
+      if (value) {
+        captured.set(slot.role, value);
+        return true;
       }
-      tokens.advance();
+      return slot.optional ?? false;
     }
-    return foundModifier ? modifiers : void 0;
+    return readRoleValue(tokens, slot, captured, this.profile);
+  }
+  maySkipSlot(patternToken, token, next) {
+    const slot = patternToken.type === "group" && patternToken.optional ? patternToken.tokens.every((t) => t.type === "role") ? patternToken.tokens[0] : void 0 : patternToken;
+    if (!slot || slot.type !== "role" || !slot.optional) return false;
+    return !!token && this.view.wouldMatch(next, token);
+  }
+  atClauseEnd(tokens) {
+    return tokens.isAtEnd();
   }
 };
-/** Maximum tokens to scan ahead when looking for a group's leading marker */
-_PatternMatcher.MAX_MARKER_SCAN = 3;
-// ==========================================================================
-// Depth Limits for Expression Parsing (security hardening)
-// ==========================================================================
-/** Maximum depth for nested property access (e.g., a.b.c.d...) */
-_PatternMatcher.MAX_PROPERTY_DEPTH = 10;
-/** Maximum number of arguments in method calls */
-_PatternMatcher.MAX_METHOD_ARGS = 20;
-// ===========================================================================
-// English Idiom Support - Noise Word Handling
-// ===========================================================================
-/**
- * Noise words that can be skipped in English for more natural syntax.
- * - "the" before selectors: "toggle the .active" → "toggle .active"
- * - "class" after class selectors: "add the .visible class" → "add .visible"
- */
-_PatternMatcher.ENGLISH_NOISE_WORDS = /* @__PURE__ */ new Set(["the", "a", "an"]);
-var PatternMatcher = _PatternMatcher;
-var patternMatcher = new PatternMatcher();
+function createStockReader(profiles = {}) {
+  return (view) => new StockValueReader(view, profiles);
+}
 
 // src/generation/pattern-generator.ts
 var defaultConfig = {
@@ -1496,6 +1867,591 @@ function renderFromSchema(node, language, tables) {
   return isSOV ? buildPhrase(...preVerb, keyword, ...postVerb) : buildPhrase(keyword, ...preVerb, ...postVerb);
 }
 
+// src/generation/schema-patterns.ts
+function createSchemaPatternGenerator(grammar) {
+  return {
+    generatePattern: (schema, profile, config) => generatePattern2(grammar, schema, profile, config),
+    generateSimplePattern: (schema, profile, config) => generateSimplePattern(grammar, schema, profile, config),
+    generateVerbFirstPattern: (schema, profile, config) => generateVerbFirstPattern(schema, profile, config),
+    generatePatternVariants: (schema, profile, config) => generatePatternVariants(grammar, schema, profile, config),
+    buildRoleToken
+  };
+}
+function withoutVariantOnlyRoles(schema) {
+  return schema.roles.some((r) => r.variantOnly) ? { ...schema, roles: schema.roles.filter((r) => !r.variantOnly) } : schema;
+}
+function sortRolesByPosition(roles, wordOrder, order) {
+  const sortKey = wordOrder === "SOV" ? "sovPosition" : "svoPosition";
+  return [...roles].sort(
+    (a, b) => order === "ascending" ? (a[sortKey] ?? 99) - (b[sortKey] ?? 99) : (b[sortKey] ?? 0) - (a[sortKey] ?? 0)
+  );
+}
+function resolveMarkerForRole(roleSpec, profile) {
+  const overrideMarker = roleSpec.markerOverride?.[profile.code];
+  const defaultMarker = profile.roleMarkers[roleSpec.role];
+  if (overrideMarker !== void 0) {
+    const alternatives = legacyMarkerAlternatives(roleSpec, profile.code, overrideMarker);
+    return {
+      primary: overrideMarker,
+      ...alternatives && { alternatives },
+      position: defaultMarker?.position ?? "before",
+      isOverride: true
+    };
+  }
+  if (defaultMarker && defaultMarker.primary) {
+    const result = {
+      primary: defaultMarker.primary,
+      position: defaultMarker.position,
+      isOverride: false
+    };
+    if (defaultMarker.alternatives) {
+      result.alternatives = defaultMarker.alternatives;
+    }
+    return result;
+  }
+  return null;
+}
+function legacyMarkerAlternatives(roleSpec, languageCode, overrideMarker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode];
+  if (!legacy?.length) return void 0;
+  const alternatives = [...new Set(legacy)].filter((a) => a && a !== overrideMarker);
+  return alternatives.length ? alternatives : void 0;
+}
+function schemaMarkerAlternatives(roleSpec, languageCode, marker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode] ?? [];
+  const variants = roleSpec.methodCarrier ? [] : roleSpec.markerVariants?.[languageCode] ?? [];
+  const alternatives = [.../* @__PURE__ */ new Set([...legacy, ...variants])].filter((a) => a && a !== marker);
+  return alternatives.length ? alternatives : void 0;
+}
+var defaultConfig2 = {
+  basePriority: 100,
+  generateSimpleVariants: true,
+  generateAlternatives: true
+};
+function generatePattern2(grammar, schema, profile, config = defaultConfig2) {
+  const id = `${schema.action}-${profile.code}-generated`;
+  const priority = config.basePriority ?? 100;
+  const keyword = profile.keywords[schema.action];
+  if (!keyword) {
+    throw new Error(`No keyword translation for '${schema.action}' in ${profile.code}`);
+  }
+  const tokens = buildTokens2(grammar, schema, profile, keyword);
+  const extraction = buildExtractionRulesWithDefaults(schema, profile);
+  const format = buildFormatString2(grammar, schema, profile, keyword);
+  return {
+    id,
+    language: profile.code,
+    command: schema.action,
+    priority,
+    template: {
+      format,
+      tokens
+    },
+    extraction
+  };
+}
+function generateSimplePattern(grammar, schema, profile, config = defaultConfig2) {
+  const optionalRoles = schema.roles.filter((r) => !r.required);
+  if (optionalRoles.length === 0) {
+    return null;
+  }
+  const requiredRoles = schema.roles.filter((r) => r.required);
+  const simpleSchema = {
+    ...schema,
+    roles: requiredRoles
+  };
+  const pattern = generatePattern2(grammar, simpleSchema, profile, config);
+  return {
+    ...pattern,
+    id: `${schema.action}-${profile.code}-generated-simple`,
+    priority: (config.basePriority ?? 100) - 5,
+    // Lower priority than full pattern (was -10)
+    extraction: buildExtractionRulesWithDefaults(schema, profile)
+  };
+}
+function generateVerbFirstPattern(schema, profile, config = defaultConfig2) {
+  if (profile.wordOrder !== "SOV") return null;
+  const requiredRoles = schema.roles.filter((r) => r.required);
+  if (requiredRoles.length !== 1) return null;
+  const keyword = profile.keywords[schema.action];
+  if (!keyword) return null;
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  const roleTokens = requiredRoles.flatMap((r) => {
+    const prefix = r.valuePrefixLiteral?.[profile.code];
+    const words = wordsFor(r, profile.code);
+    const roleToken = {
+      type: "role",
+      role: r.role,
+      optional: false,
+      expectedTypes: r.expectedTypes,
+      ...words ? { words } : {}
+    };
+    return prefix ? [{ type: "literal", value: prefix }, roleToken] : [roleToken];
+  });
+  return {
+    id: `${schema.action}-${profile.code}-generated-verb-first`,
+    language: profile.code,
+    command: schema.action,
+    // Strictly below the canonical (basePriority) and simple (basePriority - 5)
+    // patterns so native order is always preferred.
+    priority: (config.basePriority ?? 100) - 20,
+    template: {
+      format: `${keyword.primary} <${requiredRoles[0].role}>`,
+      tokens: [verbToken, ...roleTokens]
+    },
+    extraction: buildExtractionRulesWithDefaults(schema, profile)
+  };
+}
+function generatePatternVariants(grammar, schema, profile, config = defaultConfig2) {
+  const patterns = [];
+  const full = schema;
+  schema = withoutVariantOnlyRoles(schema);
+  patterns.push(generatePattern2(grammar, schema, profile, config));
+  if (config.generateSimpleVariants) {
+    const simple = generateSimplePattern(grammar, schema, profile, config);
+    if (simple) {
+      patterns.push(simple);
+    }
+  }
+  for (const omitted of schema.omitRoleVariants ?? []) {
+    const variantSchema = {
+      ...schema,
+      roles: schema.roles.filter((r) => r.role !== omitted)
+    };
+    const variant = generatePattern2(grammar, variantSchema, profile, config);
+    patterns.push({
+      ...variant,
+      id: `${schema.action}-${profile.code}-generated-no-${omitted}`,
+      priority: (config.basePriority ?? 100) - 8
+    });
+  }
+  for (const widen of schema.widenTypeVariants ?? []) {
+    if (widen.excludeLanguages?.includes(profile.code)) continue;
+    const cloneSchema = {
+      ...schema,
+      roles: schema.roles.map(
+        (r) => r.role === widen.role ? { ...r, expectedTypes: [...widen.types] } : r
+      )
+    };
+    const main = generatePattern2(grammar, cloneSchema, profile, config);
+    patterns.push({
+      ...main,
+      id: `${schema.action}-${profile.code}-generated-${widen.idSuffix}`,
+      priority: (config.basePriority ?? 100) - (widen.priorityDelta ?? 15)
+    });
+  }
+  for (const v of full.requiredRoleVariants ?? []) {
+    const variantSchema = {
+      ...full,
+      roles: full.roles.filter((r) => !v.omit?.includes(r.role)).map((r) => {
+        const required = r.role === v.role ? { ...r, required: true } : r;
+        return r.role === v.widen?.role ? { ...required, expectedTypes: [...v.widen.types] } : required;
+      })
+    };
+    const variant = generatePattern2(grammar, variantSchema, profile, config);
+    patterns.push({
+      ...variant,
+      id: `${schema.action}-${profile.code}-generated-${v.idSuffix}`,
+      priority: (config.basePriority ?? 100) + (v.priorityDelta ?? 5)
+    });
+  }
+  if (config.generateVerbFirstVariants !== false) {
+    const verbFirst = generateVerbFirstPattern(schema, profile, config);
+    if (verbFirst) {
+      patterns.push(verbFirst);
+    }
+  }
+  for (const v of schema.rolePrefixLiteralVariants ?? []) {
+    const literal = v.literal[profile.code];
+    if (!literal) continue;
+    const { rolePrefixLiteralVariants: _omitted, ...baseSchema } = schema;
+    const cloneSchema = {
+      ...baseSchema,
+      roles: schema.roles.map(
+        (r) => r.role === v.role ? { ...r, valuePrefixLiteral: { [profile.code]: literal } } : r
+      )
+    };
+    const delta = v.priorityDelta ?? 5;
+    const carrier = v.methodCarrier ? { [v.methodCarrier]: { value: literal } } : {};
+    const main = generatePattern2(grammar, cloneSchema, profile, config);
+    patterns.push({
+      ...main,
+      id: `${schema.action}-${profile.code}-generated-${v.idSuffix}`,
+      priority: (config.basePriority ?? 100) + delta,
+      extraction: { ...main.extraction, ...carrier }
+    });
+    if (config.generateVerbFirstVariants !== false) {
+      const verbFirstUrl = generateVerbFirstPattern(cloneSchema, profile, config);
+      if (verbFirstUrl) {
+        patterns.push({
+          ...verbFirstUrl,
+          id: `${schema.action}-${profile.code}-generated-verb-first-${v.idSuffix}`,
+          priority: (config.basePriority ?? 100) - 20 + delta,
+          extraction: { ...verbFirstUrl.extraction, ...carrier }
+        });
+      }
+    }
+  }
+  return patterns;
+}
+function buildTokens2(grammar, schema, profile, keyword) {
+  const tokens = [];
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  const postVerbRoles = profile.wordOrder === "SOV" ? schema.roles.filter((r) => r.sovSlot === "postVerb") : [];
+  const roleTokens = buildRoleTokens(
+    grammar,
+    postVerbRoles.length ? { ...schema, roles: schema.roles.filter((r) => r.sovSlot !== "postVerb") } : schema,
+    profile
+  );
+  const postVerbTokens = postVerbRoles.length ? buildRoleTokens(grammar, { ...schema, roles: postVerbRoles }, profile) : [];
+  switch (profile.wordOrder) {
+    case "SVO":
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+      break;
+    case "SOV":
+      tokens.push(...roleTokens);
+      tokens.push(verbToken);
+      tokens.push(...postVerbTokens);
+      break;
+    case "VSO":
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+      break;
+    default:
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+  }
+  return collapseAdjacentLiterals(tokens);
+}
+function collapseAdjacentLiterals(tokens) {
+  const out = [];
+  for (const tok of tokens) {
+    const prev = out[out.length - 1];
+    if (prev && prev.type === "literal" && tok.type === "literal" && prev.value === tok.value) {
+      const alts = [...prev.alternatives ?? [], ...tok.alternatives ?? []];
+      if (alts.length) out[out.length - 1] = { ...prev, alternatives: [...new Set(alts)] };
+      continue;
+    }
+    out.push(tok);
+  }
+  return out;
+}
+function buildRoleTokens(grammar, schema, profile) {
+  const tokens = [];
+  const sortedRoles = sortRolesByPosition(schema.roles, profile.wordOrder, grammar.positionOrder);
+  for (const roleSpec of sortedRoles) {
+    const roleToken = buildRoleToken(roleSpec, profile);
+    if (!roleSpec.required) {
+      tokens.push({
+        type: "group",
+        optional: true,
+        tokens: roleToken
+      });
+    } else {
+      tokens.push(...roleToken);
+    }
+  }
+  return tokens;
+}
+function wordsFor(roleSpec, language) {
+  if (!roleSpec.words) return void 0;
+  const words = [...roleSpec.words["*"] ?? [], ...roleSpec.words[language] ?? []];
+  return words.length > 0 ? words : void 0;
+}
+function buildRoleToken(roleSpec, profile) {
+  const tokens = [];
+  const overrideMarker = roleSpec.markerOverride?.[profile.code];
+  const defaultMarker = profile.roleMarkers[roleSpec.role];
+  const suppressMarker = roleSpec.renderOverride?.[profile.code] === "";
+  const words = wordsFor(roleSpec, profile.code);
+  const roleValueToken = {
+    type: "role",
+    role: roleSpec.role,
+    optional: !roleSpec.required,
+    expectedTypes: roleSpec.expectedTypes,
+    // The matcher reads this too — a `'keyword'`-shaped slot holds a fixed
+    // keyword phrase (`using view transition`) and must not be skipped by the
+    // trailing-slot verb guard.
+    ...roleSpec.valueShape !== void 0 ? { valueShape: roleSpec.valueShape } : {},
+    // A greedy role reads up to the next marker the pattern owes (a domain's
+    // SQL condition); its value reader does the reading.
+    ...roleSpec.greedy ? { greedy: true } : {},
+    // A role with a word list reads only one of its words.
+    ...words ? { words } : {}
+  };
+  const prefixLiteral = roleSpec.valuePrefixLiteral?.[profile.code];
+  const pushPrefixed = () => {
+    if (prefixLiteral) tokens.push({ type: "literal", value: prefixLiteral });
+    tokens.push(roleValueToken);
+  };
+  if (overrideMarker !== void 0) {
+    const markerWords = overrideMarker ? overrideMarker.split(/\s+/).filter(Boolean) : [];
+    const isPassthroughOverride = overrideMarker !== void 0 && overrideMarker === roleSpec.markerOverride?.en;
+    const position = roleSpec.markerPositionOverride?.[profile.code] ?? roleSpec.markerPosition ?? defaultMarker?.position ?? (profile.wordOrder === "SOV" && !isPassthroughOverride ? "after" : "before");
+    const optionalMarker = roleSpec.markerOptional?.[profile.code] === true;
+    const pushWord = (word) => {
+      const alternatives = markerWords.length === 1 ? schemaMarkerAlternatives(roleSpec, profile.code, word) ?? [] : [];
+      const literal = {
+        type: "literal",
+        value: word,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
+      tokens.push(optionalMarker ? { type: "group", optional: true, tokens: [literal] } : literal);
+    };
+    if (position === "before") {
+      for (const word of markerWords) pushWord(word);
+      pushPrefixed();
+    } else {
+      pushPrefixed();
+      for (const word of markerWords) pushWord(word);
+    }
+  } else if (defaultMarker) {
+    const asMarker = () => {
+      const alternatives = [
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
+      ].filter((a) => a !== defaultMarker.primary);
+      return {
+        type: "literal",
+        value: defaultMarker.primary,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
+    };
+    const pushMarker = (marker) => {
+      if (!profile.markersOptional && !roleSpec.markerOptional?.[profile.code]) {
+        tokens.push(marker);
+        return;
+      }
+      tokens.push({
+        type: "group",
+        optional: true,
+        ...profile.markersOptional && !roleSpec.markerOptional?.[profile.code] ? { renderRequired: true } : {},
+        tokens: [marker]
+      });
+    };
+    if ((roleSpec.markerPosition ?? defaultMarker.position) === "before") {
+      if (defaultMarker.primary) {
+        pushMarker(asMarker());
+      }
+      pushPrefixed();
+    } else {
+      pushPrefixed();
+      pushMarker(asMarker());
+    }
+  } else {
+    pushPrefixed();
+  }
+  return tokens;
+}
+function buildExtractionRules2(schema, profile) {
+  const rules = {};
+  for (const roleSpec of schema.roles) {
+    const overrideMarker = roleSpec.markerOverride?.[profile.code];
+    const defaultMarker = profile.roleMarkers[roleSpec.role];
+    if (roleSpec.valuePrefixLiteral?.[profile.code]) {
+      rules[roleSpec.role] = { marker: roleSpec.valuePrefixLiteral[profile.code] };
+    } else if (overrideMarker !== void 0) {
+      if (!overrideMarker) {
+        rules[roleSpec.role] = {};
+      } else {
+        const isSingleWord = !/\s/.test(overrideMarker.trim());
+        const markerAlternatives = isSingleWord ? schemaMarkerAlternatives(roleSpec, profile.code, overrideMarker) ?? [] : [];
+        rules[roleSpec.role] = markerAlternatives.length ? { marker: overrideMarker, markerAlternatives } : { marker: overrideMarker };
+      }
+    } else if (defaultMarker && defaultMarker.primary) {
+      const markerAlternatives = [
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
+      ].filter((a) => a !== defaultMarker.primary);
+      rules[roleSpec.role] = markerAlternatives.length ? { marker: defaultMarker.primary, markerAlternatives } : { marker: defaultMarker.primary };
+    } else {
+      rules[roleSpec.role] = {};
+    }
+  }
+  return rules;
+}
+function buildExtractionRulesWithDefaults(schema, profile) {
+  const baseRules = buildExtractionRules2(schema, profile);
+  const rules = {};
+  for (const roleSpec of schema.roles) {
+    const baseRule = baseRules[roleSpec.role] || {};
+    if (!roleSpec.required && roleSpec.default) {
+      rules[roleSpec.role] = { ...baseRule, default: roleSpec.default };
+    } else {
+      rules[roleSpec.role] = baseRule;
+    }
+  }
+  return rules;
+}
+function buildFormatString2(grammar, schema, profile, keyword) {
+  const parts = [];
+  const sortedRoles = sortRolesByPosition(schema.roles, profile.wordOrder, grammar.positionOrder);
+  const roleParts = sortedRoles.map((roleSpec) => {
+    const resolved = resolveMarkerForRole(roleSpec, profile);
+    let part = "";
+    if (resolved && resolved.primary) {
+      if (resolved.position === "before") {
+        part = `${resolved.primary} {${roleSpec.role}}`;
+      } else {
+        part = `{${roleSpec.role}} ${resolved.primary}`;
+      }
+    } else {
+      part = `{${roleSpec.role}}`;
+    }
+    return roleSpec.required ? part : `[${part}]`;
+  });
+  switch (profile.wordOrder) {
+    case "SVO":
+    case "VSO":
+      parts.push(keyword.primary, ...roleParts);
+      break;
+    case "SOV":
+      parts.push(...roleParts, keyword.primary);
+      break;
+    default:
+      parts.push(keyword.primary, ...roleParts);
+  }
+  return parts.join(" ");
+}
+
+// src/generation/pattern-render.ts
+var NESTED_ROLE_BONUS = 5;
+var UNCOVERED_ROLE_PENALTY = 30;
+function pinnedLiteral(rule) {
+  if (rule?.default?.type === "literal") return String(rule.default.value).trim().toLowerCase();
+  if (rule?.value !== void 0) return String(rule.value).trim().toLowerCase();
+  return void 0;
+}
+function selectRenderPattern(node, patterns, hooks) {
+  let candidates = patterns.filter((pattern) => !pattern.parseOnly);
+  if (candidates.length === 0) candidates = patterns;
+  if (hooks.candidates) candidates = hooks.candidates(node, candidates);
+  const pinnedValues = /* @__PURE__ */ new Map();
+  for (const pattern of candidates) {
+    for (const [role, rule] of Object.entries(pattern.extraction ?? {})) {
+      const key = pinnedLiteral(rule);
+      if (key === void 0) continue;
+      const set = pinnedValues.get(role) ?? /* @__PURE__ */ new Set();
+      set.add(key);
+      pinnedValues.set(role, set);
+    }
+  }
+  const scored = candidates.map((pattern) => {
+    let score = pattern.priority;
+    const hasRealRole = (role) => hooks.hasRealRole(node, role);
+    const scoreTokens = (tokens, inGroup) => {
+      for (const token of tokens) {
+        if (token.type === "group") {
+          scoreTokens(token.tokens, true);
+        } else if (token.type === "role") {
+          if (hasRealRole(token.role)) {
+            score += inGroup ? NESTED_ROLE_BONUS : 10;
+          } else if (!inGroup && !token.optional) {
+            score -= 50;
+          }
+        }
+      }
+    };
+    scoreTokens(pattern.template.tokens, false);
+    const slots = /* @__PURE__ */ new Set();
+    const collectSlots = (tokens) => {
+      for (const token of tokens) {
+        if (token.type === "group") collectSlots(token.tokens);
+        else if (token.type === "role") slots.add(token.role);
+      }
+    };
+    collectSlots(pattern.template.tokens);
+    for (const role of node.roles.keys()) {
+      if (hasRealRole(role) && !slots.has(role)) score -= UNCOVERED_ROLE_PENALTY;
+    }
+    for (const [role, rule] of Object.entries(pattern.extraction ?? {})) {
+      const pinnedKey = pinnedLiteral(rule);
+      if (pinnedKey === void 0) continue;
+      const actual = node.roles.get(role);
+      const actualKey = actual?.type === (rule.valueIsExpression ? "expression" : "literal") ? String(
+        actual.type === "expression" ? actual.raw : actual.value
+      ).trim().toLowerCase() : void 0;
+      if (actualKey === pinnedKey) {
+        score += 60;
+      } else if (actualKey === void 0 || pinnedValues.get(role)?.has(actualKey)) {
+        score -= 200;
+      }
+    }
+    score += hooks.adjustScore?.(pattern, node) ?? 0;
+    return { pattern, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  return scored.length > 0 ? scored[0].pattern : null;
+}
+function renderPattern(node, pattern, hooks) {
+  const parts = [];
+  const language = pattern.language;
+  const tokens = pattern.template.tokens;
+  for (let i = 0; i < tokens.length; i++) {
+    hooks.beforeToken?.(tokens, i, parts, node, language);
+    const span = hooks.span?.(tokens, i, node, language, true);
+    if (span !== void 0) {
+      parts.push(span.text);
+      i += span.tokens - 1;
+      continue;
+    }
+    const token = tokens[i];
+    const rendered = renderPatternToken(token, node, language, hooks);
+    if (rendered !== null) {
+      pushPart(hooks, parts, rendered, token, tokens[i - 1], node, language);
+      hooks.afterToken?.(token, parts.length - 1, node);
+    }
+  }
+  return parts;
+}
+function pushPart(hooks, parts, text, token, previous, node, language) {
+  if (hooks.pushPart) hooks.pushPart(parts, text, token, previous, node, language);
+  else parts.push(text);
+}
+function renderPatternToken(token, node, language, hooks) {
+  switch (token.type) {
+    case "literal":
+      return token.renderSuppress ? null : token.value;
+    case "role":
+      return hooks.writeRole(token, node, language);
+    case "group": {
+      const hasRequired = token.tokens.filter((t) => t.type === "role" && !t.optional).every((t) => node.roles.has(t.role));
+      if (!hasRequired && token.optional) {
+        return null;
+      }
+      if (hooks.writeGroup && !hooks.writeGroup(token, node, language)) return null;
+      const groupParts = [];
+      let hasRoleValue = false;
+      for (let i = 0; i < token.tokens.length; i++) {
+        const span = hooks.span?.(token.tokens, i, node, language, false);
+        if (span !== void 0) {
+          groupParts.push(span.text);
+          hasRoleValue = true;
+          i += span.tokens - 1;
+          continue;
+        }
+        const subToken = token.tokens[i];
+        const rendered = renderPatternToken(subToken, node, language, hooks);
+        if (rendered !== null) {
+          pushPart(hooks, groupParts, rendered, subToken, token.tokens[i - 1], node, language);
+          if (subToken.type === "role") hasRoleValue = true;
+        }
+      }
+      if (token.optional && !hasRoleValue && !token.renderRequired) return null;
+      return groupParts.length > 0 ? groupParts.join(" ") : null;
+    }
+    default:
+      return null;
+  }
+}
+
 // src/grammar/types.ts
 function reorderRoles(roles, targetOrder) {
   const result = [];
@@ -1747,12 +2703,15 @@ function readingDifference(source, back) {
 
 // src/api/create-dsl.ts
 var UnreadInputError = class extends Error {
-  constructor(input, language, reading, unread) {
-    super(`"${input}" (${language}) reads as ${reading.action} only by leaving "${unread}" unread`);
+  constructor(input, language, reading, unread, hint) {
+    super(
+      `"${input}" (${language}) reads as ${reading.action} only by leaving "${unread}" unread` + (hint ? `; ${hint}` : "")
+    );
     this.input = input;
     this.language = language;
     this.reading = reading;
     this.unread = unread;
+    this.hint = hint;
     this.code = "unread-input";
     this.name = "UnreadInputError";
   }
@@ -1777,7 +2736,8 @@ var DSLRegistry = class {
    *   subset of the DSL's languages. A built-in command missing a keyword stays
    *   an error, since that is a domain-authoring mistake.
    */
-  constructor(config, partiallyTranslatedActions = /* @__PURE__ */ new Set()) {
+  constructor(config, partiallyTranslatedActions, generate) {
+    this.generate = generate;
     this.patterns = /* @__PURE__ */ new Map();
     this.tokenizers = /* @__PURE__ */ new Map();
     this.schemas = config.schemas;
@@ -1793,7 +2753,7 @@ var DSLRegistry = class {
       if (this.partiallyTranslatedActions.has(schema.action) && !lang.patternProfile.keywords[schema.action]) {
         continue;
       }
-      const pattern = generatePattern(schema, lang.patternProfile);
+      const pattern = this.generate(schema, lang.patternProfile);
       patterns.push(pattern);
     }
     this.patterns.set(lang.code, patterns);
@@ -1809,9 +2769,9 @@ var DSLRegistry = class {
   }
 };
 var MultilingualDSLImpl = class {
-  constructor(config, registry, transformer, profileProvider) {
+  constructor(config, registry, transformer, profileProvider, engine) {
     this.registry = registry;
-    this.matcher = new PatternMatcher();
+    this.match = engine.match;
     this.transformer = transformer;
     this.profileProvider = profileProvider;
     if (config.codeGenerator) {
@@ -1824,10 +2784,7 @@ var MultilingualDSLImpl = class {
     for (const extension of config.extensions ?? []) {
       if (extension.render) this.extensionRenderers.set(extension.schema.action, extension.render);
     }
-    this.schemaFallbackRenderer = createDomainRenderer({
-      schemas: config.schemas,
-      profiles: config.languages.map((l) => l.patternProfile)
-    });
+    this.schemaFallbackRenderer = engine.fallbackRenderer(config, registry);
     const schemaMap = new Map(config.schemas.map((s) => [s.action, s]));
     this.schemaLookup = {
       getSchema: (action) => schemaMap.get(action)
@@ -1851,15 +2808,12 @@ var MultilingualDSLImpl = class {
     }
     const tokens = tokenizer.tokenize(input);
     const patterns = this.registry.getPatterns(language);
-    const profile = {
-      code: language
-    };
     const total = tokens.tokens.length;
     let best = null;
     let longestPartial = null;
     for (const pattern of patterns) {
       const mark = tokens.mark();
-      const match = this.matcher.matchPattern(tokens, pattern, profile);
+      const match = this.match(tokens, pattern, language);
       tokens.reset(mark);
       if (!match) continue;
       if (match.consumedTokens < total) {
@@ -1876,15 +2830,32 @@ var MultilingualDSLImpl = class {
     }
     if (longestPartial) {
       const unread = tokens.tokens.slice(longestPartial.consumedTokens).map((t) => t.value).join(" ");
+      const hint = this.quoteHint(longestPartial, tokens.tokens);
       throw new UnreadInputError(
         input,
         language,
         this.nodeOf(longestPartial, input, language),
-        unread
+        unread,
+        ...hint ? [hint] : []
       );
     }
     throw new Error(`No pattern matched for input: ${input}`);
   }
+  /**
+   * `if "buy milk" is one value, quote it`, where the last token a match read is a bare word it took
+   * as a role's value (a role with no word list) and the first it left is a bare word too.
+   */
+  quoteHint(match, tokens) {
+    const last = tokens[match.consumedTokens - 1];
+    const next = tokens[match.consumedTokens];
+    if (last?.kind !== "identifier" || next?.kind !== "identifier") return void 0;
+    const schema = this.schemaLookup.getSchema(match.pattern.command);
+    const role = [...match.captured].find(
+      ([, v]) => v.raw === last.value
+    )?.[0];
+    if (!role || schema?.roles.find((r) => r.role === role)?.words) return void 0;
+    return `if "${last.value} ${next.value}" is one value, quote it`;
+  }
   nodeOf(match, input, language) {
     return {
       kind: "command",
@@ -2103,8 +3074,76 @@ function createMultilingualDSL(config) {
     dictionary,
     profileProvider
   });
-  const registry = new DSLRegistry(effectiveConfig, extensionActions);
-  return new MultilingualDSLImpl(effectiveConfig, registry, transformer, profileProvider);
+  const engine = engineFor(config);
+  const registry = new DSLRegistry(effectiveConfig, extensionActions, engine.generate);
+  return new MultilingualDSLImpl(effectiveConfig, registry, transformer, profileProvider, engine);
+}
+function engineFor(config) {
+  const name = config.engine ?? "classic";
+  if (name === "classic") return classicEngine();
+  if (name === "core") return coreEngine();
+  throw new Error(`Unknown DSL engine "${String(name)}" (expected "classic" or "core")`);
+}
+function classicEngine() {
+  const matcher = new PatternMatcher();
+  return {
+    generate: (schema, profile) => generatePattern(schema, profile),
+    match: (tokens, pattern, language) => matcher.matchPattern(tokens, pattern, { code: language }),
+    fallbackRenderer: (config) => createDomainRenderer({
+      schemas: config.schemas,
+      profiles: config.languages.map((l) => l.patternProfile)
+    })
+  };
+}
+function schemaProfileOf(profile) {
+  const side = profile.wordOrder === "SOV" ? "after" : "before";
+  const roleMarkers = {};
+  for (const [role, marker] of Object.entries(profile.roleMarkers ?? {})) {
+    roleMarkers[role] = {
+      primary: marker.primary,
+      ...marker.alternatives ? { alternatives: marker.alternatives } : {},
+      position: marker.position ?? side
+    };
+  }
+  return {
+    code: profile.code,
+    wordOrder: profile.wordOrder,
+    keywords: profile.keywords,
+    roleMarkers
+  };
+}
+function coreEngine() {
+  const generator = createSchemaPatternGenerator({ positionOrder: "descending" });
+  const matcher = new MatchSkeleton(createStockReader(), stockConfidenceModel);
+  return {
+    generate: (schema, profile) => generator.generatePattern(schema, schemaProfileOf(profile)),
+    match: (tokens, pattern) => matcher.matchPattern(tokens, pattern),
+    fallbackRenderer: (config, registry) => {
+      const schemas = new Map(config.schemas.map((s) => [s.action, s]));
+      const hooks = {
+        hasRealRole: (node, role) => {
+          const value = node.roles.get(role);
+          return value !== void 0 && value.implicit !== true;
+        },
+        writeRole: (token, node) => {
+          if (!node.roles.has(token.role)) return null;
+          let value = extractRoleValue(node, token.role);
+          const spec = schemas.get(node.action)?.roles.find((r) => r.role === token.role);
+          if (spec?.quoteMultiword && /\s/.test(value) && !/^(["']).*\1$/.test(value)) {
+            value = `"${value}"`;
+          }
+          return value || null;
+        }
+      };
+      return (node, language) => {
+        const patterns = registry.getPatterns(language).filter((p) => p.command === node.action);
+        const pattern = selectRenderPattern(node, patterns, hooks);
+        if (!pattern) return null;
+        const text = renderPattern(node, pattern, hooks).join(" ");
+        return text || null;
+      };
+    }
+  };
 }
 
 // src/prompts/prompt-generator.ts
@@ -3400,11 +4439,58 @@ var CrossDomainDispatcher = class {
     return idx === -1 ? this.priority.length : idx;
   }
 };
+
+// src/api/translation-loss.ts
+var LossyTranslationError = class extends Error {
+  constructor(partial, loss, from, to) {
+    super(
+      `translation ${from} \u2192 ${to} would lose part of the script (${loss.kind}): ` + loss.lost.join(", ")
+    );
+    this.partial = partial;
+    this.loss = loss;
+    this.from = from;
+    this.to = to;
+    this.name = "LossyTranslationError";
+  }
+};
+function unconsumedSpans(node) {
+  const out = [];
+  for (const d of node.diagnostics ?? []) {
+    if (d.code !== "unconsumed-input") continue;
+    out.push(/"(.*)"\s*$/s.exec(d.message)?.[1] ?? d.message);
+  }
+  return out;
+}
+function findTranslationLoss(input, node, output, readBack, rules) {
+  const unread = unconsumedSpans(node);
+  if (unread.length) return { kind: "truncation", lost: unread };
+  const unwritable = rules.unwritable?.(node) ?? [];
+  if (unwritable.length) return { kind: "core-only", lost: unwritable };
+  let back;
+  try {
+    back = readBack(output);
+  } catch (e) {
+    return { kind: "read-back", lost: [`the output does not read: ${e.message}`] };
+  }
+  const misread = unconsumedSpans(back);
+  if (misread.length) return { kind: "read-back", lost: misread };
+  const written = rules.written ? rules.written(node) : node;
+  for (const difference of rules.differences) {
+    const lost = difference(written, back);
+    if (lost.length) return { kind: "read-back", lost };
+  }
+  const values = rules.missingValues?.(input, output) ?? [];
+  if (values.length) return { kind: "invariant", lost: values };
+  return void 0;
+}
 export {
   CrossDomainDispatcher,
   DomainRegistry,
+  LossyTranslationError,
   TranslationReadBackError,
   UnreadInputError,
-  createMultilingualDSL
+  createMultilingualDSL,
+  findTranslationLoss,
+  unconsumedSpans
 };
 //# sourceMappingURL=index.js.map