@lokascript/framework 4.7.0 → 5.0.0

package/dist/index.js

@@ -19,256 +19,670 @@ import {
   getRoleValue
 } from "@lokascript/intent";
 
-// src/core/logger.ts
-var DebugLogger = class {
-  constructor(namespace) {
-    this.namespace = namespace;
-    this.enabled = this.checkEnabled();
+// src/core/tokenization/token-utils.ts
+var TokenStreamImpl = class {
+  constructor(tokens, language) {
+    this.pos = 0;
+    this.tokens = tokens;
+    this.language = language;
   }
-  checkEnabled() {
-    if (typeof process !== "undefined" && process.env) {
-      const DEBUG = process.env.DEBUG || "";
-      return DEBUG === "*" || DEBUG.includes("framework:*") || DEBUG.includes(`framework:${this.namespace}`);
+  peek(offset = 0) {
+    const index = this.pos + offset;
+    if (index < 0 || index >= this.tokens.length) {
+      return null;
     }
-    return false;
+    return this.tokens[index];
   }
-  log(level, message, ...args) {
-    if (!this.enabled) return;
-    const prefix = `[framework:${this.namespace}]`;
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    switch (level) {
-      case "debug":
-        console.debug(`${timestamp} ${prefix} DEBUG:`, message, ...args);
-        break;
-      case "info":
-        console.info(`${timestamp} ${prefix} INFO:`, message, ...args);
-        break;
-      case "warn":
-        console.warn(`${timestamp} ${prefix} WARN:`, message, ...args);
-        break;
-      case "error":
-        console.error(`${timestamp} ${prefix} ERROR:`, message, ...args);
-        break;
+  advance() {
+    if (this.isAtEnd()) {
+      throw new Error("Unexpected end of token stream");
     }
+    return this.tokens[this.pos++];
   }
-  debug(message, ...args) {
-    this.log("debug", message, ...args);
+  isAtEnd() {
+    return this.pos >= this.tokens.length;
   }
-  info(message, ...args) {
-    this.log("info", message, ...args);
+  mark() {
+    return { position: this.pos };
   }
-  warn(message, ...args) {
-    this.log("warn", message, ...args);
+  reset(mark) {
+    this.pos = mark.position;
   }
-  error(message, ...args) {
-    this.log("error", message, ...args);
+  position() {
+    return this.pos;
   }
   /**
-   * Check if logging is enabled for this namespace.
+   * Get remaining tokens as an array.
    */
-  isEnabled() {
-    return this.enabled;
+  remaining() {
+    return this.tokens.slice(this.pos);
   }
   /**
-   * Programmatically enable logging for this namespace.
+   * Consume tokens while predicate is true.
    */
-  enable() {
-    this.enabled = true;
+  takeWhile(predicate) {
+    const result = [];
+    while (!this.isAtEnd() && predicate(this.peek())) {
+      result.push(this.advance());
+    }
+    return result;
   }
   /**
-   * Programmatically disable logging for this namespace.
+   * Skip tokens while predicate is true.
    */
-  disable() {
-    this.enabled = false;
+  skipWhile(predicate) {
+    while (!this.isAtEnd() && predicate(this.peek())) {
+      this.advance();
+    }
   }
 };
-function createLogger(namespace) {
-  return new DebugLogger(namespace);
+function createPosition(start, end) {
+  return { start, end };
 }
-
-// src/core/pattern-matching/utils/type-validation.ts
-function isTypeCompatible(actualType, expectedTypes) {
-  if (!expectedTypes || expectedTypes.length === 0) {
-    return true;
-  }
-  if (expectedTypes.includes(actualType)) {
-    return true;
+function createToken(valueOrParams, kind, position, normalizedOrOptions) {
+  if (typeof valueOrParams === "object") {
+    const { value: value2, kind: kind2, position: position2, normalized: normalized2, stem, stemConfidence, metadata } = valueOrParams;
+    return {
+      value: value2,
+      kind: kind2,
+      position: position2,
+      ...normalized2 !== void 0 && { normalized: normalized2 },
+      ...stem !== void 0 && { stem },
+      ...stemConfidence !== void 0 && { stemConfidence },
+      ...metadata !== void 0 && { metadata }
+    };
   }
-  if (expectedTypes.includes("expression")) {
-    return true;
+  const value = valueOrParams;
+  if (!kind || !position) {
+    throw new Error("createToken requires kind and position parameters");
   }
-  if (actualType === "property-path") {
-    return expectedTypes.some((t) => ["selector", "reference", "expression"].includes(t));
+  if (typeof normalizedOrOptions === "string") {
+    return { value, kind, position, normalized: normalizedOrOptions };
   }
-  return false;
-}
-function validateValueType(value, expectedTypes) {
-  if (!expectedTypes || expectedTypes.length === 0) {
-    return true;
+  if (normalizedOrOptions) {
+    const { normalized: normalized2, stem, stemConfidence, metadata } = normalizedOrOptions;
+    return {
+      value,
+      kind,
+      position,
+      ...normalized2 !== void 0 && { normalized: normalized2 },
+      ...stem !== void 0 && { stem },
+      ...stemConfidence !== void 0 && { stemConfidence },
+      ...metadata !== void 0 && { metadata }
+    };
   }
-  return isTypeCompatible(value.type, expectedTypes);
-}
-function isCSSSelector(value) {
-  return value.startsWith(".") || value.startsWith("#") || value.startsWith("<");
-}
-function isClassName(value) {
-  return value.startsWith(".");
-}
-function isIdSelector(value) {
-  return value.startsWith("#");
-}
-function isCSSPropertyRef(value) {
-  return value.startsWith("*");
+  return { value, kind, position };
 }
-function isNumericValue(value) {
-  const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
-  if (durationMatch) {
-    return true;
-  }
-  const num = parseFloat(value);
-  return !isNaN(num) && isFinite(num);
+function isWhitespace(char) {
+  return /\s/.test(char);
 }
-function isPropertyName(value) {
-  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value);
+function isSelectorStart(char) {
+  return char === "#" || char === "." || char === "[" || char === "@" || char === "*" || char === "<";
 }
-function isVariableRef(value) {
-  return value.startsWith(":");
+function isQuote(char) {
+  return char === '"' || char === "'" || char === "`" || char === "\u300C" || char === "\u300D";
 }
-function isBuiltInReference(value) {
-  const builtIns = /* @__PURE__ */ new Set(["me", "you", "it", "result", "event", "target", "body"]);
-  return builtIns.has(value.toLowerCase());
+function isDigit(char) {
+  return /\d/.test(char);
 }
-
-// src/core/pattern-matching/utils/possessive-keywords.ts
-function getPossessiveReference(profile, keyword) {
-  return profile?.possessive?.keywords?.[keyword];
+function stripOptionalDiacritics(word) {
+  return word.replace(/[\u064b-\u0652\u0670]/g, "");
 }
-function isPossessiveKeyword(profile, keyword) {
-  return profile?.possessive?.keywords?.[keyword] !== void 0;
+function isAsciiLetter(char) {
+  return /[a-zA-Z]/.test(char);
 }
-function getAllPossessiveKeywords(profile) {
-  return profile?.possessive?.keywords ?? {};
+function isAsciiIdentifierChar(char) {
+  return /[a-zA-Z0-9_-]/.test(char);
 }
 
-// src/core/matching/stock-reading.ts
-function isValidReference(_value) {
-  return false;
+// src/core/matching/match-skeleton.ts
+function groupHasRole(group) {
+  return group.tokens.some((t) => t.type === "role" || t.type === "group" && groupHasRole(t));
 }
-function safeToLowerCase(value) {
-  if (typeof value === "string") {
-    return value.toLowerCase();
-  }
-  if (value === null || value === void 0) {
-    return "";
+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)
+    });
   }
-  return String(value).toLowerCase();
-}
-function readRoleValue(tokens, patternToken, captured, profile) {
-  skipNoiseWords(tokens);
-  const token = tokens.peek();
-  if (!token) {
-    return patternToken.optional || false;
+  /**
+   * 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?.()
+    };
   }
-  const possessiveValue = tryMatchPossessiveExpression(tokens, profile);
-  if (possessiveValue) {
-    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-      if (!isTypeCompatible(possessiveValue.type, patternToken.expectedTypes)) {
-        return patternToken.optional || false;
+  /**
+   * 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);
     }
-    captured.set(patternToken.role, possessiveValue);
-    return true;
+    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;
   }
-  const methodCallValue = tryMatchMethodCallExpression(tokens);
-  if (methodCallValue) {
-    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-      if (!isTypeCompatible(methodCallValue.type, patternToken.expectedTypes)) {
-        return patternToken.optional || false;
+  /**
+   * Match a sequence of pattern tokens against the token stream.
+   */
+  matchTokenSequence(tokens, patternTokens, captured, nextAfterSequence) {
+    this.reader.skipLeading?.(tokens, patternTokens);
+    for (let i = 0; i < patternTokens.length; i++) {
+      const patternToken = patternTokens[i];
+      this.reader.beforePatternToken?.(tokens, patternTokens, i, captured);
+      if (this.reader.maySkipSlot(
+        patternToken,
+        tokens.peek(),
+        patternTokens[i + 1] ?? nextAfterSequence
+      )) {
+        const skipMark = tokens.mark();
+        const speculative = new Map(captured);
+        if (this.matchTokenSequence(
+          tokens,
+          patternTokens.slice(i + 1),
+          speculative,
+          nextAfterSequence
+        ) && this.reader.atClauseEnd(tokens)) {
+          captured.clear();
+          for (const [role, value] of speculative) captured.set(role, value);
+          return true;
+        }
+        tokens.reset(skipMark);
+      }
+      const outerRest = this.patternRest;
+      this.patternRest = [...patternTokens.slice(i + 1), ...outerRest];
+      this.slotAfterLiteral = patternToken.type === "role" && patternTokens[i - 1]?.type === "literal";
+      const matched = this.matchPatternToken(
+        tokens,
+        patternToken,
+        captured,
+        patternTokens[i + 1] ?? nextAfterSequence
+      );
+      this.patternRest = outerRest;
+      if (!matched) {
+        if (this.isOptional(patternToken)) {
+          continue;
+        }
+        return false;
       }
     }
-    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;
+  /**
+   * Match a single pattern token against the current position in the stream.
+   */
+  matchPatternToken(tokens, patternToken, captured, nextPatternToken) {
+    switch (patternToken.type) {
+      case "literal":
+        return this.matchLiteralToken(tokens, patternToken);
+      case "role": {
+        const roleStart = tokens.position();
+        const matchedRole = this.reader.readRole(tokens, patternToken, captured, nextPatternToken);
+        if (matchedRole && captured.has(patternToken.role)) {
+          this.roleStarts.set(patternToken.role, roleStart);
+        }
+        return matchedRole;
       }
+      case "group":
+        return this.matchGroupToken(tokens, patternToken, captured, nextPatternToken);
+      default:
+        return false;
     }
-    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;
+  /**
+   * Match a literal pattern token (keyword or particle).
+   */
+  matchLiteralToken(tokens, patternToken) {
+    const token = tokens.peek();
+    if (!token) return false;
+    const matchType = this.getMatchType(token, patternToken.value);
+    if (matchType !== "none") {
+      this.totalKeywordMatches++;
+      if (matchType === "stem") {
+        this.stemMatchCount++;
       }
+      tokens.advance();
+      return true;
     }
-    captured.set(patternToken.role, propertyAccessValue);
-    return true;
+    if (patternToken.alternatives) {
+      for (const alt of patternToken.alternatives) {
+        const altMatchType = this.getMatchType(token, alt);
+        if (altMatchType !== "none") {
+          this.totalKeywordMatches++;
+          if (altMatchType === "stem") {
+            this.stemMatchCount++;
+          }
+          tokens.advance();
+          return true;
+        }
+      }
+    }
+    for (const value of [patternToken.value, ...patternToken.alternatives ?? []]) {
+      for (const sep of ["-", "_"]) {
+        if (value.includes(sep) && this.tryMatchShatteredCompound(tokens, value, sep)) {
+          this.totalKeywordMatches++;
+          return true;
+        }
+      }
+    }
+    return false;
   }
-  const selectorPropertyValue = tryMatchSelectorPropertyExpression(tokens);
-  if (selectorPropertyValue) {
-    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-      if (!isTypeCompatible(selectorPropertyValue.type, patternToken.expectedTypes)) {
-        return patternToken.optional || false;
+  /**
+   * Match a compound keyword (`titik-henti`, `по_умолчанию`) against a
+   * shattered token run (`titik` `-` `henti` / `по` `_` `умолчанию`): word
+   * segments must be identifier/keyword/particle tokens equal to the expected
+   * segments (case-insensitive; particle because prepositions like ru `по` /
+   * uk `за` lead some underscore compounds), separators lone `sep` tokens.
+   * Consumes the run on success, resets the stream on failure.
+   */
+  tryMatchShatteredCompound(tokens, expected, sep) {
+    const segments = expected.split(sep);
+    if (segments.length < 2 || segments.some((s) => s.length === 0)) return false;
+    const mark = tokens.mark();
+    for (let i = 0; i < segments.length; i++) {
+      if (i > 0) {
+        const sepToken = tokens.peek();
+        if (!sepToken || sepToken.value !== sep) {
+          tokens.reset(mark);
+          return false;
+        }
+        tokens.advance();
+      }
+      const word = tokens.peek();
+      if (!word || word.kind !== "identifier" && word.kind !== "keyword" && word.kind !== "particle" || word.value.toLowerCase() !== segments[i].toLowerCase()) {
+        tokens.reset(mark);
+        return false;
       }
+      tokens.advance();
     }
-    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)) {
+  /**
+   * Match a group pattern token (optional sequence).
+   */
+  matchGroupToken(tokens, patternToken, captured, nextPatternToken) {
+    const mark = tokens.mark();
+    const capturedBefore = new Map(captured);
+    let success = this.matchTokenSequence(tokens, patternToken.tokens, captured, nextPatternToken);
+    if (success && tokens.position() > mark.position && groupHasRole(patternToken) && [...captured].every(([role, value]) => capturedBefore.get(role) === value) && captured.size === capturedBefore.size) {
+      success = false;
+    }
+    if (success) {
+      const markerLiterals = [];
+      for (const inner of patternToken.tokens) {
+        if (inner.type === "group" && inner.renderRequired) {
+          for (const t of inner.tokens) {
+            if (t.type === "literal") markerLiterals.push(t.value, ...t.alternatives ?? []);
+          }
+        }
+      }
+      if (markerLiterals.length > 0) {
+        const addedRole = [...captured.keys()].some((role) => !capturedBefore.has(role));
+        if (addedRole) {
+          const last = tokens.tokens[tokens.position() - 1];
+          const markerSeen = last !== void 0 && tokens.position() > mark.position && markerLiterals.some((lit) => this.getMatchType(last, lit) !== "none");
+          if (!markerSeen) success = false;
+        }
+      }
+    }
+    if (!success) {
+      tokens.reset(mark);
+      for (const role of captured.keys()) {
+        if (!capturedBefore.has(role)) {
+          captured.delete(role);
+        }
+      }
+      for (const [role, value] of capturedBefore) {
+        if (captured.get(role) !== value) {
+          captured.set(role, value);
+        }
+      }
       return patternToken.optional || false;
     }
+    return true;
   }
-  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();
+  /**
+   * 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");
     }
-    const nextPeek = tokens.peek();
-    if (nextPeek?.kind === "literal" && nextPeek.value.startsWith("(")) {
-      chainedProps += nextPeek.value;
-      tokens.advance();
+    if (pt.type === "group") {
+      return this.patternTokenWouldMatch(pt.tokens?.[0], token);
     }
-    return createPropertyPath(createReference(baseRef), chainedProps);
+    return false;
   }
-  tokens.reset(mark);
-  return null;
-}
-function isStructuralKeyword(value) {
+  /**
+   * Get the type of match for a token against a value.
+   * Used for confidence calculation.
+   */
+  getMatchType(token, value) {
+    if (token.value === value) return "exact";
+    if (token.normalized === value) return "normalized";
+    if (token.stem === value && token.stemConfidence !== void 0 && token.stemConfidence >= 0.7) {
+      return "stem";
+    }
+    if (token.kind === "keyword" && token.value.toLowerCase() === value.toLowerCase()) {
+      return "case-insensitive";
+    }
+    if (token.kind === "keyword") {
+      const strippedToken = stripOptionalDiacritics(token.value).toLowerCase();
+      if (strippedToken && strippedToken === stripOptionalDiacritics(value).toLowerCase()) {
+        return "case-insensitive";
+      }
+    }
+    return "none";
+  }
+  /**
+   * Apply extraction rules to fill in static values and defaults for missing
+   * roles, and re-shape captured roles that declare a `transform` (the
+   * ExtractionRule field was documented but unwired — go-qu-url-dest is the
+   * first consumer: it re-types the marker-bound capture to the expression
+   * shape the en reference produces).
+   */
+  applyExtractionRules(pattern, captured) {
+    for (const [role, rule] of Object.entries(pattern.extraction)) {
+      const existing = captured.get(role);
+      if (existing) {
+        if (rule.transform) {
+          const raw = existing.type === "literal" ? String(existing.value) : String(existing.raw ?? "");
+          captured.set(role, rule.transform(raw));
+        }
+      } else if (rule.value !== void 0) {
+        captured.set(
+          role,
+          rule.valueIsExpression ? { type: "expression", raw: rule.value } : { type: "literal", value: rule.value }
+        );
+      } else if (rule.default) {
+        const implicitDefault = {
+          ...rule.default,
+          implicit: true
+        };
+        captured.set(role, implicitDefault);
+      }
+    }
+  }
+  /**
+   * Check if a pattern token is optional.
+   */
+  isOptional(patternToken) {
+    return patternToken.type !== "literal" && patternToken.optional === true;
+  }
+};
+
+// src/core/matching/type-validation.ts
+function isTypeCompatible(actualType, expectedTypes) {
+  if (!expectedTypes || expectedTypes.length === 0) {
+    return true;
+  }
+  if (expectedTypes.includes(actualType)) {
+    return true;
+  }
+  if (expectedTypes.includes("expression")) {
+    return true;
+  }
+  if (actualType === "property-path") {
+    return expectedTypes.some((t) => ["selector", "reference", "expression"].includes(t));
+  }
+  return false;
+}
+function validateValueType(value, expectedTypes) {
+  if (!expectedTypes || expectedTypes.length === 0) {
+    return true;
+  }
+  return isTypeCompatible(value.type, expectedTypes);
+}
+function isCSSSelector(value) {
+  return value.startsWith(".") || value.startsWith("#") || value.startsWith("<");
+}
+function isClassName(value) {
+  return value.startsWith(".");
+}
+function isIdSelector(value) {
+  return value.startsWith("#");
+}
+function isCSSPropertyRef(value) {
+  return value.startsWith("*");
+}
+function isNumericValue(value) {
+  const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (durationMatch) {
+    return true;
+  }
+  const num = parseFloat(value);
+  return !isNaN(num) && isFinite(num);
+}
+function isPropertyName(value) {
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value);
+}
+function isVariableRef(value) {
+  return value.startsWith(":");
+}
+function isBuiltInReference(value) {
+  const builtIns = /* @__PURE__ */ new Set(["me", "you", "it", "result", "event", "target", "body"]);
+  return builtIns.has(value.toLowerCase());
+}
+
+// src/core/matching/possessive-keywords.ts
+function getPossessiveReference(profile, keyword) {
+  return profile?.possessive?.keywords?.[keyword];
+}
+function isPossessiveKeyword(profile, keyword) {
+  return profile?.possessive?.keywords?.[keyword] !== void 0;
+}
+function getAllPossessiveKeywords(profile) {
+  return profile?.possessive?.keywords ?? {};
+}
+
+// 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",
@@ -481,1195 +895,64 @@ function tokenToSemanticValue(token) {
       if (isValidReference(lower)) {
         return createReference(lower);
       }
-      return createLiteral(token.normalized || token.value);
-    }
-    case "identifier": {
-      if (typeof token.value === "string" && token.value.startsWith(":")) {
-        return createReference(token.value);
-      }
-      const identLower = safeToLowerCase(token.value);
-      if (isValidReference(identLower)) {
-        return createReference(identLower);
-      }
-      return { type: "expression", raw: token.value };
-    }
-    case "url":
-      return createLiteral(token.value, "string");
-    default:
-      return null;
-  }
-}
-function parseLiteralValue(value) {
-  if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
-    const inner = value.slice(1, -1);
-    return createLiteral(inner, "string");
-  }
-  if (value === "true") return createLiteral(true, "boolean");
-  if (value === "false") return createLiteral(false, "boolean");
-  const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
-  if (durationMatch) {
-    const num2 = parseFloat(durationMatch[1]);
-    const unit = durationMatch[2];
-    if (unit) {
-      return createLiteral(value, "duration");
-    }
-    return createLiteral(num2, "number");
-  }
-  const num = parseFloat(value);
-  if (!isNaN(num)) {
-    return createLiteral(num, "number");
-  }
-  return createLiteral(value, "string");
-}
-var ENGLISH_NOISE_WORDS = /* @__PURE__ */ new Set(["the", "a", "an"]);
-function skipNoiseWords(tokens) {
-  const token = tokens.peek();
-  if (!token) return;
-  const tokenLower = safeToLowerCase(token.value);
-  if (ENGLISH_NOISE_WORDS.has(tokenLower)) {
-    const mark = tokens.mark();
-    tokens.advance();
-    const nextToken = tokens.peek();
-    if (nextToken && nextToken.kind === "selector") {
-      return;
-    }
-    tokens.reset(mark);
-  }
-  if (tokenLower === "class") {
-    tokens.advance();
-  }
-}
-
-// src/core/matching/stock-confidence.ts
-function scoreParts(ctx) {
-  const { pattern, captured } = ctx;
-  let score = 0;
-  let maxScore = 0;
-  const hasDefault = (role) => {
-    return pattern.extraction?.[role]?.default !== void 0;
-  };
-  for (const token of pattern.template.tokens) {
-    if (token.type === "role") {
-      maxScore += 1;
-      if (captured.has(token.role)) {
-        score += 1;
-      }
-    } else if (token.type === "group") {
-      for (const subToken of token.tokens) {
-        if (subToken.type === "role") {
-          const roleHasDefault = hasDefault(subToken.role);
-          const weight = 0.8;
-          maxScore += weight;
-          if (captured.has(subToken.role)) {
-            score += weight;
-          } else if (roleHasDefault) {
-            score += weight * 0.6;
-          }
-        }
-      }
-    }
-  }
-  const roleCoverage = maxScore > 0 ? score / maxScore : 1;
-  let baseConfidence = roleCoverage;
-  let stemPenalty = 0;
-  if (ctx.stemMatchCount > 0 && ctx.totalKeywordMatches > 0) {
-    stemPenalty = ctx.stemMatchCount / ctx.totalKeywordMatches * 0.15;
-    baseConfidence = Math.max(0.5, baseConfidence - stemPenalty);
-  }
-  const vsoBoost = calculateVSOConfidenceBoost(pattern);
-  baseConfidence = Math.min(1, baseConfidence + vsoBoost);
-  const prepositionAdjustment = arabicPrepositionDisambiguation(pattern, captured);
-  baseConfidence = Math.max(0, Math.min(1, baseConfidence + prepositionAdjustment));
-  return {
-    roleCoverage,
-    stemPenalty,
-    languageBoost: vsoBoost,
-    languageAdjustment: prepositionAdjustment,
-    final: baseConfidence
-  };
-}
-function calculateVSOConfidenceBoost(pattern) {
-  if (pattern.language !== "ar") {
-    return 0;
-  }
-  const firstToken = pattern.template.tokens[0];
-  if (!firstToken || firstToken.type !== "literal") {
-    return 0;
-  }
-  const ARABIC_VERBS = /* @__PURE__ */ new Set([
-    "\u0628\u062F\u0644",
-    "\u063A\u064A\u0631",
-    "\u0623\u0636\u0641",
-    "\u0623\u0632\u0644",
-    "\u0636\u0639",
-    "\u0627\u062C\u0639\u0644",
-    "\u0639\u064A\u0646",
-    "\u0632\u062F",
-    "\u0627\u0646\u0642\u0635",
-    "\u0633\u062C\u0644",
-    "\u0623\u0638\u0647\u0631",
-    "\u0623\u062E\u0641",
-    "\u0634\u063A\u0644",
-    "\u0623\u0631\u0633\u0644",
-    "\u0631\u0643\u0632",
-    "\u0634\u0648\u0634",
-    "\u062A\u0648\u0642\u0641",
-    "\u0627\u0646\u0633\u062E",
-    "\u0627\u062D\u0630\u0641",
-    "\u0627\u0635\u0646\u0639",
-    "\u0627\u0646\u062A\u0638\u0631",
-    "\u0627\u0646\u062A\u0642\u0627\u0644",
-    "\u0623\u0648"
-  ]);
-  if (ARABIC_VERBS.has(firstToken.value)) {
-    return 0.15;
-  }
-  if (firstToken.alternatives) {
-    for (const alt of firstToken.alternatives) {
-      if (ARABIC_VERBS.has(alt)) {
-        return 0.15;
-      }
-    }
-  }
-  return 0;
-}
-function arabicPrepositionDisambiguation(pattern, captured) {
-  if (pattern.language !== "ar") {
-    return 0;
-  }
-  let adjustment = 0;
-  const PREFERRED_PREPOSITIONS = {
-    patient: ["\u0639\u0644\u0649"],
-    // element selectors prefer على (on/upon)
-    destination: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
-    // destination prefers إلى (to)
-    source: ["\u0645\u0646"],
-    // source prefers من (from)
-    agent: ["\u0645\u0646"],
-    // agent/by prefers من (from/by)
-    manner: ["\u0628"],
-    // manner prefers ب (with/by)
-    style: ["\u0628"],
-    // style prefers ب (with)
-    goal: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
-    // target state prefers إلى (to)
-    method: ["\u0628"]
-    // method prefers ب (with/by)
-  };
-  for (const [role, value] of captured.entries()) {
-    const preferred = PREFERRED_PREPOSITIONS[role];
-    if (!preferred || preferred.length === 0) {
-      continue;
-    }
-    const metadata = "metadata" in value ? value.metadata : void 0;
-    if (metadata && typeof metadata.prepositionValue === "string") {
-      const usedPreposition = metadata.prepositionValue;
-      if (preferred.includes(usedPreposition)) {
-        adjustment += 0.1;
-      } else {
-        adjustment -= 0.1;
-      }
-    }
-  }
-  return Math.max(-0.1, Math.min(0.1, adjustment));
-}
-var stockConfidenceModel = {
-  calculate: (ctx) => scoreParts(ctx).final,
-  calculateWithBreakdown: (ctx) => scoreParts(ctx)
-};
-
-// src/core/pattern-matching/pattern-matcher.ts
-var _PatternMatcher = class _PatternMatcher {
-  constructor() {
-    /** Debug logger */
-    this.logger = createLogger("pattern-matcher");
-    /**
-     * Track stem matches for confidence calculation.
-     * This is set during matching and read during confidence calculation.
-     */
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-  }
-  /**
-   * Try to match a single pattern against the token stream.
-   * Returns the match result or null if no match.
-   *
-   * @param tokens - Token stream to match against
-   * @param pattern - Pattern to match
-   * @param profile - Optional language profile for possessive handling
-   */
-  matchPattern(tokens, pattern, profile) {
-    const mark = tokens.mark();
-    const captured = /* @__PURE__ */ new Map();
-    this.logger.debug("========================================");
-    this.logger.debug("matchPattern ENTRY");
-    this.logger.debug("Pattern ID:", pattern.id);
-    this.logger.debug("Pattern command:", pattern.command);
-    this.logger.debug("Pattern language:", pattern.language);
-    this.logger.debug("Pattern template:", JSON.stringify(pattern.template, null, 2));
-    if (this.logger.isEnabled()) {
-      const firstTokens = [];
-      for (let i = 0; i < 10; i++) {
-        const t = tokens.peek(i);
-        if (t)
-          firstTokens.push({
-            type: t.type,
-            value: t.value,
-            kind: t.kind
-          });
-        else break;
-      }
-      this.logger.debug("Input tokens (first 10):", firstTokens);
-      this.logger.debug("Profile code:", profile?.code);
-    }
-    this.currentProfile = profile;
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-    this.logger.debug("--- Calling matchTokenSequence ---");
-    this.logger.debug("Pattern tokens to match:", JSON.stringify(pattern.template.tokens, null, 2));
-    const success = this.matchTokenSequence(tokens, pattern.template.tokens, captured);
-    this.logger.debug("matchTokenSequence returned:", success);
-    this.logger.debug(
-      "Captured roles:",
-      Array.from(captured.entries()).map(([k, v]) => [k, JSON.stringify(v)])
-    );
-    if (!success) {
-      this.logger.debug(">>> MATCH FAILED - resetting token position");
-      tokens.reset(mark);
-      return null;
-    }
-    const confidence = stockConfidenceModel.calculate({
-      pattern,
-      captured,
-      stemMatchCount: this.stemMatchCount,
-      totalKeywordMatches: this.totalKeywordMatches
-    });
-    this.applyExtractionRules(pattern, captured);
-    return {
-      pattern,
-      captured,
-      consumedTokens: tokens.position() - mark.position,
-      confidence
-    };
-  }
-  /**
-   * Try to match multiple patterns, return the best match.
-   *
-   * @param tokens - Token stream to match against
-   * @param patterns - Candidate patterns to try
-   * @param profile - Optional language profile for possessive handling
-   */
-  matchBest(tokens, patterns, profile) {
-    const matches = [];
-    for (const pattern of patterns) {
-      const mark = tokens.mark();
-      const result = this.matchPattern(tokens, pattern, profile);
-      if (result) {
-        matches.push(result);
-      }
-      tokens.reset(mark);
-    }
-    if (matches.length === 0) {
-      return null;
-    }
-    matches.sort((a, b) => {
-      const priorityDiff = b.pattern.priority - a.pattern.priority;
-      if (priorityDiff !== 0) return priorityDiff;
-      const confidenceDiff = b.confidence - a.confidence;
-      if (Math.abs(confidenceDiff) > 1e-3) return confidenceDiff;
-      return b.consumedTokens - a.consumedTokens;
-    });
-    const best = matches[0];
-    this.matchPattern(tokens, best.pattern);
-    return best;
-  }
-  /**
-   * Match a sequence of pattern tokens against the token stream.
-   *
-   * Supports bounded single-step backtracking: if an optional role consumes
-   * a token and the immediately following pattern token fails, the matcher
-   * resets to before the optional role and retries the failed token.
-   */
-  matchTokenSequence(tokens, patternTokens, captured, parentStopMarkers) {
-    const firstPatternToken = patternTokens[0];
-    const patternExpectsConjunction = firstPatternToken?.type === "literal" && (firstPatternToken.value === "and" || firstPatternToken.value === "then" || firstPatternToken.alternatives?.includes("and") || firstPatternToken.alternatives?.includes("then"));
-    if (this.currentProfile?.code === "ar" && !patternExpectsConjunction) {
-      while (tokens.peek()?.kind === "conjunction") {
-        tokens.advance();
-      }
-    }
-    let prevOptionalMark = null;
-    let prevOptionalRole = null;
-    for (let i = 0; i < patternTokens.length; i++) {
-      const patternToken = patternTokens[i];
-      this.logger.debug("  >> Matching pattern token:", JSON.stringify(patternToken, null, 2));
-      const currTok = tokens.peek();
-      this.logger.debug(
-        "  >> Current input token:",
-        currTok ? JSON.stringify({
-          type: currTok.type,
-          value: currTok.value,
-          kind: currTok.kind
-        }) : "EOF"
-      );
-      if (patternToken.type === "role" && patternToken.greedy) {
-        const stopMarkers = this.collectStopMarkers(patternTokens, i + 1);
-        if (parentStopMarkers) {
-          for (const m of parentStopMarkers) stopMarkers.add(m);
-        }
-        const values = [];
-        while (!tokens.isAtEnd()) {
-          const nextToken = tokens.peek();
-          if (!nextToken) break;
-          if (this.isStopMarker(nextToken, stopMarkers)) break;
-          values.push(nextToken.value);
-          tokens.advance();
-        }
-        if (values.length > 0) {
-          captured.set(patternToken.role, { type: "expression", raw: values.join(" ") });
-          prevOptionalMark = null;
-          prevOptionalRole = null;
-          continue;
-        } else if (patternToken.optional) {
-          continue;
-        } else {
-          return false;
-        }
-      }
-      if (patternToken.type === "group") {
-        const siblingStopMarkers = this.collectStopMarkers(patternTokens, i + 1);
-        if (parentStopMarkers) {
-          for (const m of parentStopMarkers) siblingStopMarkers.add(m);
-        }
-        const groupMatched = this.matchGroupToken(
-          tokens,
-          patternToken,
-          captured,
-          siblingStopMarkers
-        );
-        if (groupMatched) {
-          prevOptionalMark = null;
-          prevOptionalRole = null;
-          continue;
-        }
-        if (this.isOptional(patternToken)) {
-          continue;
-        }
-        return false;
-      }
-      const isOptionalRole = patternToken.type === "role" && patternToken.optional === true;
-      const markBefore = isOptionalRole ? tokens.mark() : null;
-      const isRoleToken = patternToken.type === "role";
-      if (isRoleToken && !isOptionalRole) {
-        const nextPT = i + 1 < patternTokens.length ? patternTokens[i + 1] : null;
-        if (nextPT?.type === "literal") {
-          const currentToken = tokens.peek();
-          if (currentToken && this.getMatchType(currentToken, nextPT.value) !== "none") {
-            this.logger.debug(
-              "  >> MARKER-STEAL GUARD: current token matches next literal, skipping role"
-            );
-            this.logger.debug("  >> Token match FAILED");
-            if (this.isOptional(patternToken)) {
-              continue;
-            }
-            if (prevOptionalMark && prevOptionalRole) {
-              this.logger.debug("  >> BACKTRACKING: undoing optional role", prevOptionalRole);
-              tokens.reset(prevOptionalMark);
-              captured.delete(prevOptionalRole);
-              prevOptionalMark = null;
-              prevOptionalRole = null;
-              const retryMatched = this.matchPatternToken(tokens, patternToken, captured);
-              this.logger.debug("  >> Backtrack retry result:", retryMatched);
-              if (retryMatched) {
-                continue;
-              }
-            }
-            return false;
-          }
-        }
-      }
-      const matched = this.matchPatternToken(tokens, patternToken, captured);
-      this.logger.debug("  >> Match result:", matched);
-      if (matched) {
-        if (isOptionalRole) {
-          prevOptionalMark = markBefore;
-          prevOptionalRole = patternToken.role;
-        } else {
-          prevOptionalMark = null;
-          prevOptionalRole = null;
-        }
-        continue;
-      }
-      this.logger.debug("  >> Token match FAILED");
-      if (this.isOptional(patternToken)) {
-        continue;
-      }
-      if (prevOptionalMark && prevOptionalRole) {
-        this.logger.debug("  >> BACKTRACKING: undoing optional role", prevOptionalRole);
-        tokens.reset(prevOptionalMark);
-        captured.delete(prevOptionalRole);
-        prevOptionalMark = null;
-        prevOptionalRole = null;
-        const retryMatched = this.matchPatternToken(tokens, patternToken, captured);
-        this.logger.debug("  >> Backtrack retry result:", retryMatched);
-        if (retryMatched) {
-          continue;
-        }
-      }
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Match a single pattern token against the current position in the stream.
-   */
-  matchPatternToken(tokens, patternToken, captured) {
-    switch (patternToken.type) {
-      case "literal":
-        return this.matchLiteralToken(tokens, patternToken);
-      case "role":
-        return readRoleValue(tokens, patternToken, captured, this.currentProfile);
-      case "group":
-        return this.matchGroupToken(tokens, patternToken, captured);
-      default:
-        return false;
-    }
-  }
-  /**
-   * Match a literal pattern token (keyword or particle).
-   */
-  matchLiteralToken(tokens, patternToken) {
-    const token = tokens.peek();
-    this.logger.debug("    >>> matchLiteralToken: expecting", patternToken.value);
-    this.logger.debug(
-      "    >>> matchLiteralToken: got token",
-      token ? JSON.stringify({
-        type: token.type,
-        value: token.value,
-        kind: token.kind
-      }) : "null"
-    );
-    if (!token) {
-      this.logger.debug("    >>> matchLiteralToken: FAIL - no token");
-      return false;
-    }
-    const matchType = this.getMatchType(token, patternToken.value);
-    this.logger.debug(
-      "    >>> matchType for",
-      token.value,
-      "vs",
-      patternToken.value,
-      ":",
-      matchType
-    );
-    if (matchType !== "none") {
-      this.totalKeywordMatches++;
-      if (matchType === "stem") {
-        this.stemMatchCount++;
-      }
-      tokens.advance();
-      return true;
-    }
-    if (patternToken.alternatives) {
-      for (const alt of patternToken.alternatives) {
-        const altMatchType = this.getMatchType(token, alt);
-        if (altMatchType !== "none") {
-          this.totalKeywordMatches++;
-          if (altMatchType === "stem") {
-            this.stemMatchCount++;
-          }
-          tokens.advance();
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  /**
-   * Match a group pattern token (optional sequence).
-   * When the group's leading marker isn't at the current position, scans ahead
-   * up to MAX_MARKER_SCAN tokens to find it. This allows unmarked tokens
-   * (e.g., a value like 'hello') to sit between groups without blocking later
-   * marker matches.
-   */
-  matchGroupToken(tokens, patternToken, captured, parentStopMarkers) {
-    const mark = tokens.mark();
-    const capturedBefore = new Set(captured.keys());
-    const success = this.matchTokenSequence(
-      tokens,
-      patternToken.tokens,
-      captured,
-      parentStopMarkers
-    );
-    if (success) return true;
-    tokens.reset(mark);
-    for (const role of captured.keys()) {
-      if (!capturedBefore.has(role)) captured.delete(role);
-    }
-    if (!patternToken.optional) return false;
-    const leadingMarker = this.getGroupLeadingMarker(patternToken);
-    if (leadingMarker) {
-      for (let offset = 1; offset <= _PatternMatcher.MAX_MARKER_SCAN; offset++) {
-        const ahead = tokens.peek(offset);
-        if (!ahead) break;
-        const aheadValue = (ahead.normalized || ahead.value).toLowerCase();
-        if (aheadValue === leadingMarker) {
-          this.logger.debug(
-            "  >> MARKER SCAN: found",
-            leadingMarker,
-            "at offset",
-            offset,
-            "- skipping intervening tokens"
-          );
-          for (let s = 0; s < offset; s++) tokens.advance();
-          const retrySuccess = this.matchTokenSequence(
-            tokens,
-            patternToken.tokens,
-            captured,
-            parentStopMarkers
-          );
-          if (retrySuccess) return true;
-          tokens.reset(mark);
-          for (const role of captured.keys()) {
-            if (!capturedBefore.has(role)) captured.delete(role);
-          }
-          break;
-        }
-      }
-    }
-    return true;
-  }
-  /**
-   * Get the leading marker literal from an optional group.
-   * Returns the lowercase marker value, or null if the group
-   * doesn't start with a literal token (e.g., SOV groups where
-   * the role comes before the marker).
-   */
-  getGroupLeadingMarker(group) {
-    const first = group.tokens[0];
-    if (first?.type === "literal") return first.value.toLowerCase();
-    return null;
-  }
-  /**
-   * Get the type of match for a token against a value.
-   * Used for confidence calculation.
-   */
-  getMatchType(token, value) {
-    if (token.value === value) return "exact";
-    if (token.normalized === value) return "normalized";
-    if (token.stem === value && token.stemConfidence !== void 0 && token.stemConfidence >= 0.7) {
-      return "stem";
-    }
-    if (token.kind === "keyword" && safeToLowerCase(token.value) === value.toLowerCase()) {
-      return "case-insensitive";
-    }
-    return "none";
-  }
-  /**
-   * Collect literal values from upcoming pattern tokens that act as stop markers
-   * for greedy role capture. Returns the set of lowercase values.
-   */
-  collectStopMarkers(patternTokens, startIndex) {
-    const markers = /* @__PURE__ */ new Set();
-    for (let j = startIndex; j < patternTokens.length; j++) {
-      const pt = patternTokens[j];
-      if (pt.type === "literal") {
-        markers.add(pt.value.toLowerCase());
-        if (pt.alternatives) {
-          for (const alt of pt.alternatives) {
-            markers.add(alt.toLowerCase());
-          }
-        }
-        break;
-      }
-      if (pt.type === "group") {
-        for (const gt of pt.tokens) {
-          if (gt.type === "literal") {
-            markers.add(gt.value.toLowerCase());
-            if (gt.alternatives) {
-              for (const alt of gt.alternatives) {
-                markers.add(alt.toLowerCase());
-              }
-            }
-            break;
-          }
-        }
-        if (!pt.optional) break;
-      }
-    }
-    return markers;
-  }
-  /**
-   * Check if a token matches any stop marker for greedy capture.
-   */
-  isStopMarker(token, stopMarkers) {
-    if (stopMarkers.size === 0) return false;
-    if (stopMarkers.has(token.value.toLowerCase())) return true;
-    if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
-    return false;
-  }
-  // ==========================================================================
-  // Depth Limits for Expression Parsing (security hardening)
-  // ==========================================================================
-  /**
-   * Apply extraction rules to fill in static values and defaults for missing roles.
-   */
-  applyExtractionRules(pattern, captured) {
-    for (const [role, rule] of Object.entries(pattern.extraction)) {
-      if (!captured.has(role)) {
-        if (rule.value !== void 0) {
-          captured.set(role, { type: "literal", value: rule.value });
-        } else if (rule.default) {
-          captured.set(role, rule.default);
-        }
-      }
-    }
-  }
-  /**
-   * Check if a pattern token is optional.
-   */
-  isOptional(patternToken) {
-    return patternToken.type !== "literal" && patternToken.optional === true;
-  }
-  // ===========================================================================
-  // English Idiom Support - Noise Word Handling
-  // ===========================================================================
-  /**
-   * Extract event modifiers from the token stream.
-   * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
-   * that can appear after event names.
-   *
-   * Returns EventModifiers object or undefined if no modifiers found.
-   */
-  extractEventModifiers(tokens) {
-    const modifiers = {};
-    let foundModifier = false;
-    while (!tokens.isAtEnd()) {
-      const token = tokens.peek();
-      if (!token || token.kind !== "event-modifier") {
-        break;
-      }
-      const metadata = token.metadata;
-      if (!metadata) {
-        break;
-      }
-      foundModifier = true;
-      switch (metadata.modifierName) {
-        case "once":
-          modifiers.once = true;
-          break;
-        case "debounce":
-          if (typeof metadata.value === "number") {
-            modifiers.debounce = metadata.value;
-          }
-          break;
-        case "throttle":
-          if (typeof metadata.value === "number") {
-            modifiers.throttle = metadata.value;
-          }
-          break;
-        case "queue":
-          if (metadata.value === "first" || metadata.value === "last" || metadata.value === "all" || metadata.value === "none") {
-            modifiers.queue = metadata.value;
-          }
-          break;
-      }
-      tokens.advance();
-    }
-    return foundModifier ? modifiers : void 0;
-  }
-};
-/** Maximum tokens to scan ahead when looking for a group's leading marker */
-_PatternMatcher.MAX_MARKER_SCAN = 3;
-var PatternMatcher = _PatternMatcher;
-var patternMatcher = new PatternMatcher();
-function matchPattern(tokens, pattern) {
-  return patternMatcher.matchPattern(tokens, pattern);
-}
-function matchBest(tokens, patterns) {
-  return patternMatcher.matchBest(tokens, patterns);
-}
-
-// src/core/tokenization/token-utils.ts
-var TokenStreamImpl = class {
-  constructor(tokens, language) {
-    this.pos = 0;
-    this.tokens = tokens;
-    this.language = language;
-  }
-  peek(offset = 0) {
-    const index = this.pos + offset;
-    if (index < 0 || index >= this.tokens.length) {
-      return null;
-    }
-    return this.tokens[index];
-  }
-  advance() {
-    if (this.isAtEnd()) {
-      throw new Error("Unexpected end of token stream");
-    }
-    return this.tokens[this.pos++];
-  }
-  isAtEnd() {
-    return this.pos >= this.tokens.length;
-  }
-  mark() {
-    return { position: this.pos };
-  }
-  reset(mark) {
-    this.pos = mark.position;
-  }
-  position() {
-    return this.pos;
-  }
-  /**
-   * Get remaining tokens as an array.
-   */
-  remaining() {
-    return this.tokens.slice(this.pos);
-  }
-  /**
-   * Consume tokens while predicate is true.
-   */
-  takeWhile(predicate) {
-    const result = [];
-    while (!this.isAtEnd() && predicate(this.peek())) {
-      result.push(this.advance());
-    }
-    return result;
-  }
-  /**
-   * Skip tokens while predicate is true.
-   */
-  skipWhile(predicate) {
-    while (!this.isAtEnd() && predicate(this.peek())) {
-      this.advance();
-    }
-  }
-};
-function createPosition(start, end) {
-  return { start, end };
-}
-function createToken(valueOrParams, kind, position, normalizedOrOptions) {
-  if (typeof valueOrParams === "object") {
-    const { value: value2, kind: kind2, position: position2, normalized: normalized2, stem, stemConfidence, metadata } = valueOrParams;
-    return {
-      value: value2,
-      kind: kind2,
-      position: position2,
-      ...normalized2 !== void 0 && { normalized: normalized2 },
-      ...stem !== void 0 && { stem },
-      ...stemConfidence !== void 0 && { stemConfidence },
-      ...metadata !== void 0 && { metadata }
-    };
-  }
-  const value = valueOrParams;
-  if (!kind || !position) {
-    throw new Error("createToken requires kind and position parameters");
-  }
-  if (typeof normalizedOrOptions === "string") {
-    return { value, kind, position, normalized: normalizedOrOptions };
-  }
-  if (normalizedOrOptions) {
-    const { normalized: normalized2, stem, stemConfidence, metadata } = normalizedOrOptions;
-    return {
-      value,
-      kind,
-      position,
-      ...normalized2 !== void 0 && { normalized: normalized2 },
-      ...stem !== void 0 && { stem },
-      ...stemConfidence !== void 0 && { stemConfidence },
-      ...metadata !== void 0 && { metadata }
-    };
-  }
-  return { value, kind, position };
-}
-function isWhitespace(char) {
-  return /\s/.test(char);
-}
-function isSelectorStart(char) {
-  return char === "#" || char === "." || char === "[" || char === "@" || char === "*" || char === "<";
-}
-function isQuote(char) {
-  return char === '"' || char === "'" || char === "`" || char === "\u300C" || char === "\u300D";
-}
-function isDigit(char) {
-  return /\d/.test(char);
-}
-function stripOptionalDiacritics(word) {
-  return word.replace(/[\u064b-\u0652\u0670]/g, "");
-}
-function isAsciiLetter(char) {
-  return /[a-zA-Z]/.test(char);
-}
-function isAsciiIdentifierChar(char) {
-  return /[a-zA-Z0-9_-]/.test(char);
-}
-
-// src/core/matching/match-skeleton.ts
-function groupHasRole(group) {
-  return group.tokens.some((t) => t.type === "role" || t.type === "group" && groupHasRole(t));
-}
-var MatchSkeleton = class {
-  /**
-   * @param makeReader - builds the grammar's reader, handed this matcher's view
-   *   of the match in progress (one reader per matcher).
-   */
-  constructor(makeReader, confidenceModel) {
-    /**
-     * The pattern tokens still to match after the one being matched, through
-     * every enclosing group: a value stops at any marker the pattern still owes.
-     */
-    this.patternRest = [];
-    /**
-     * Whether the role slot being matched directly follows a literal the pattern
-     * matched: its marker (`[por {quantity}]`), or the command's verb.
-     */
-    this.slotAfterLiteral = false;
-    /**
-     * Selective memoization cache (Phase 6.1).
-     * Caches pattern match results keyed by `tokenPosition:patternId`.
-     * Cleared before each top-level matchBest() call.
-     */
-    this.matchCache = /* @__PURE__ */ new Map();
-    /**
-     * Stream index where each role's capture began, for the current
-     * `matchPattern` call. Rebuilt per call, written on the same success path as
-     * `captured` — see `PatternMatchResult.roleStarts`.
-     */
-    this.roleStarts = /* @__PURE__ */ new Map();
-    /**
-     * Track stem matches for confidence calculation.
-     * This is set during matching and read during confidence calculation.
-     */
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-    this.confidenceModel = confidenceModel;
-    this.reader = makeReader({
-      patternRest: () => this.patternRest,
-      slotAfterLiteral: () => this.slotAfterLiteral,
-      wouldMatch: (pt, token) => this.patternTokenWouldMatch(pt, token)
-    });
-  }
-  /**
-   * Try to match a single pattern against the token stream.
-   * Returns the match result or null if no match.
-   */
-  matchPattern(tokens, pattern) {
-    const mark = tokens.mark();
-    const captured = /* @__PURE__ */ new Map();
-    this.reader.beginPattern(pattern);
-    this.stemMatchCount = 0;
-    this.totalKeywordMatches = 0;
-    this.roleStarts = /* @__PURE__ */ new Map();
-    this.patternRest = [];
-    const success = this.matchTokenSequence(tokens, pattern.template.tokens, captured);
-    if (!success) {
-      tokens.reset(mark);
-      return null;
-    }
-    const confidence = this.confidenceModel.calculate({
-      pattern,
-      captured,
-      stemMatchCount: this.stemMatchCount,
-      totalKeywordMatches: this.totalKeywordMatches
-    });
-    this.applyExtractionRules(pattern, captured);
-    return {
-      pattern,
-      captured,
-      consumedTokens: tokens.position() - mark.position,
-      confidence,
-      roleStarts: this.roleStarts,
-      ...this.reader.resultFields?.()
-    };
-  }
-  /**
-   * Try to match multiple patterns, return the best match.
-   */
-  matchBest(tokens, patterns) {
-    this.matchCache.clear();
-    const matches = [];
-    const startPos = tokens.position();
-    for (const pattern of patterns) {
-      const mark = tokens.mark();
-      const cacheKey = `${startPos}:${pattern.id}`;
-      let result;
-      if (this.matchCache.has(cacheKey)) {
-        result = this.matchCache.get(cacheKey);
-      } else {
-        result = this.matchPattern(tokens, pattern);
-        this.matchCache.set(cacheKey, result);
-      }
-      if (result) {
-        matches.push(result);
-      }
-      tokens.reset(mark);
-    }
-    if (matches.length === 0) {
-      return null;
-    }
-    matches.sort((a, b) => {
-      const priorityDiff = b.pattern.priority - a.pattern.priority;
-      if (priorityDiff !== 0) return priorityDiff;
-      return b.confidence - a.confidence;
-    });
-    const best = matches[0];
-    this.matchPattern(tokens, best.pattern);
-    return best;
-  }
-  /**
-   * Match a sequence of pattern tokens against the token stream.
-   */
-  matchTokenSequence(tokens, patternTokens, captured, nextAfterSequence) {
-    this.reader.skipLeading?.(tokens, patternTokens);
-    for (let i = 0; i < patternTokens.length; i++) {
-      const patternToken = patternTokens[i];
-      this.reader.beforePatternToken?.(tokens, patternTokens, i, captured);
-      if (this.reader.maySkipSlot(
-        patternToken,
-        tokens.peek(),
-        patternTokens[i + 1] ?? nextAfterSequence
-      )) {
-        const skipMark = tokens.mark();
-        const speculative = new Map(captured);
-        if (this.matchTokenSequence(
-          tokens,
-          patternTokens.slice(i + 1),
-          speculative,
-          nextAfterSequence
-        ) && this.reader.atClauseEnd(tokens)) {
-          captured.clear();
-          for (const [role, value] of speculative) captured.set(role, value);
-          return true;
-        }
-        tokens.reset(skipMark);
-      }
-      const outerRest = this.patternRest;
-      this.patternRest = [...patternTokens.slice(i + 1), ...outerRest];
-      this.slotAfterLiteral = patternToken.type === "role" && patternTokens[i - 1]?.type === "literal";
-      const matched = this.matchPatternToken(
-        tokens,
-        patternToken,
-        captured,
-        patternTokens[i + 1] ?? nextAfterSequence
-      );
-      this.patternRest = outerRest;
-      if (!matched) {
-        if (this.isOptional(patternToken)) {
-          continue;
-        }
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Match a single pattern token against the current position in the stream.
-   */
-  matchPatternToken(tokens, patternToken, captured, nextPatternToken) {
-    switch (patternToken.type) {
-      case "literal":
-        return this.matchLiteralToken(tokens, patternToken);
-      case "role": {
-        const roleStart = tokens.position();
-        const matchedRole = this.reader.readRole(tokens, patternToken, captured, nextPatternToken);
-        if (matchedRole && captured.has(patternToken.role)) {
-          this.roleStarts.set(patternToken.role, roleStart);
-        }
-        return matchedRole;
-      }
-      case "group":
-        return this.matchGroupToken(tokens, patternToken, captured, nextPatternToken);
-      default:
-        return false;
-    }
-  }
-  /**
-   * Match a literal pattern token (keyword or particle).
-   */
-  matchLiteralToken(tokens, patternToken) {
-    const token = tokens.peek();
-    if (!token) return false;
-    const matchType = this.getMatchType(token, patternToken.value);
-    if (matchType !== "none") {
-      this.totalKeywordMatches++;
-      if (matchType === "stem") {
-        this.stemMatchCount++;
-      }
-      tokens.advance();
-      return true;
-    }
-    if (patternToken.alternatives) {
-      for (const alt of patternToken.alternatives) {
-        const altMatchType = this.getMatchType(token, alt);
-        if (altMatchType !== "none") {
-          this.totalKeywordMatches++;
-          if (altMatchType === "stem") {
-            this.stemMatchCount++;
-          }
-          tokens.advance();
-          return true;
-        }
-      }
-    }
-    for (const value of [patternToken.value, ...patternToken.alternatives ?? []]) {
-      for (const sep of ["-", "_"]) {
-        if (value.includes(sep) && this.tryMatchShatteredCompound(tokens, value, sep)) {
-          this.totalKeywordMatches++;
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  /**
-   * Match a compound keyword (`titik-henti`, `по_умолчанию`) against a
-   * shattered token run (`titik` `-` `henti` / `по` `_` `умолчанию`): word
-   * segments must be identifier/keyword/particle tokens equal to the expected
-   * segments (case-insensitive; particle because prepositions like ru `по` /
-   * uk `за` lead some underscore compounds), separators lone `sep` tokens.
-   * Consumes the run on success, resets the stream on failure.
-   */
-  tryMatchShatteredCompound(tokens, expected, sep) {
-    const segments = expected.split(sep);
-    if (segments.length < 2 || segments.some((s) => s.length === 0)) return false;
-    const mark = tokens.mark();
-    for (let i = 0; i < segments.length; i++) {
-      if (i > 0) {
-        const sepToken = tokens.peek();
-        if (!sepToken || sepToken.value !== sep) {
-          tokens.reset(mark);
-          return false;
-        }
-        tokens.advance();
-      }
-      const word = tokens.peek();
-      if (!word || word.kind !== "identifier" && word.kind !== "keyword" && word.kind !== "particle" || word.value.toLowerCase() !== segments[i].toLowerCase()) {
-        tokens.reset(mark);
-        return false;
-      }
-      tokens.advance();
-    }
-    return true;
-  }
-  /**
-   * Match a group pattern token (optional sequence).
-   */
-  matchGroupToken(tokens, patternToken, captured, nextPatternToken) {
-    const mark = tokens.mark();
-    const capturedBefore = new Map(captured);
-    let success = this.matchTokenSequence(tokens, patternToken.tokens, captured, nextPatternToken);
-    if (success && tokens.position() > mark.position && groupHasRole(patternToken) && [...captured].every(([role, value]) => capturedBefore.get(role) === value) && captured.size === capturedBefore.size) {
-      success = false;
-    }
-    if (success) {
-      const markerLiterals = [];
-      for (const inner of patternToken.tokens) {
-        if (inner.type === "group" && inner.renderRequired) {
-          for (const t of inner.tokens) {
-            if (t.type === "literal") markerLiterals.push(t.value, ...t.alternatives ?? []);
-          }
-        }
-      }
-      if (markerLiterals.length > 0) {
-        const addedRole = [...captured.keys()].some((role) => !capturedBefore.has(role));
-        if (addedRole) {
-          const last = tokens.tokens[tokens.position() - 1];
-          const markerSeen = last !== void 0 && tokens.position() > mark.position && markerLiterals.some((lit) => this.getMatchType(last, lit) !== "none");
-          if (!markerSeen) success = false;
-        }
-      }
-    }
-    if (!success) {
-      tokens.reset(mark);
-      for (const role of captured.keys()) {
-        if (!capturedBefore.has(role)) {
-          captured.delete(role);
-        }
-      }
-      for (const [role, value] of capturedBefore) {
-        if (captured.get(role) !== value) {
-          captured.set(role, value);
-        }
-      }
-      return patternToken.optional || false;
-    }
-    return true;
-  }
-  /**
-   * Whether a pattern token (literal, or a group starting with a literal) would
-   * match the given stream token. Used to keep the event-head source-clause
-   * consumption from stealing a marker the pattern explicitly expects.
-   */
-  patternTokenWouldMatch(pt, token) {
-    if (!pt) return false;
-    if (pt.type === "literal") {
-      if (this.getMatchType(token, pt.value) !== "none") return true;
-      return !!pt.alternatives?.some((a) => this.getMatchType(token, a) !== "none");
-    }
-    if (pt.type === "group") {
-      return this.patternTokenWouldMatch(pt.tokens?.[0], token);
-    }
-    return false;
-  }
-  /**
-   * Get the type of match for a token against a value.
-   * Used for confidence calculation.
-   */
-  getMatchType(token, value) {
-    if (token.value === value) return "exact";
-    if (token.normalized === value) return "normalized";
-    if (token.stem === value && token.stemConfidence !== void 0 && token.stemConfidence >= 0.7) {
-      return "stem";
-    }
-    if (token.kind === "keyword" && token.value.toLowerCase() === value.toLowerCase()) {
-      return "case-insensitive";
-    }
-    if (token.kind === "keyword") {
-      const strippedToken = stripOptionalDiacritics(token.value).toLowerCase();
-      if (strippedToken && strippedToken === stripOptionalDiacritics(value).toLowerCase()) {
-        return "case-insensitive";
+      return 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 };
     }
-    return "none";
+    case "url":
+      return createLiteral(token.value, "string");
+    default:
+      return null;
   }
-  /**
-   * 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);
-      }
+}
+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");
   }
-  /**
-   * Check if a pattern token is optional.
-   */
-  isOptional(patternToken) {
-    return patternToken.type !== "literal" && patternToken.optional === true;
+  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-reader.ts
 function greedyStopMarkers(rest) {
@@ -1706,6 +989,11 @@ function readGreedy(tokens, stopMarkers) {
   }
   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;
@@ -1738,6 +1026,11 @@ var StockValueReader = class {
       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) {
@@ -1761,284 +1054,151 @@ function createStockReader(profiles = {}) {
   return (view) => new StockValueReader(view, profiles);
 }
 
-// src/generation/pattern-generator.ts
-var defaultConfig = {
-  basePriority: 100,
-  includeOptionalVariants: true
-};
-function generatePattern(schema, profile, config = defaultConfig) {
-  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 = buildTokens(schema, profile, keyword.primary, keyword.alternatives);
-  const extraction = buildExtractionRules(schema, profile);
-  const format = buildFormatString(schema, profile, keyword.primary);
-  return {
-    id,
-    language: profile.code,
-    command: schema.action,
-    priority,
-    template: {
-      format,
-      tokens
-    },
-    extraction
-  };
-}
-function buildTokens(schema, profile, keyword, alternatives) {
-  const tokens = [];
-  const keywordToken = {
-    type: "literal",
-    value: keyword,
-    ...alternatives?.length && { alternatives }
-  };
-  const sortedRoles = sortRolesByWordOrder(schema.roles, profile.wordOrder);
-  if (profile.wordOrder === "SVO") {
-    tokens.push(keywordToken);
-    for (const role of sortedRoles) {
-      addRoleWithMarker(tokens, role, profile);
-    }
-  } else if (profile.wordOrder === "SOV") {
-    const preVerb = [];
-    const postVerb = [];
-    for (const role of sortedRoles) {
-      addRoleWithMarker(role.sovSlot === "postVerb" ? postVerb : preVerb, role, profile);
-    }
-    tokens.push(...preVerb, keywordToken, ...postVerb);
-  } else if (profile.wordOrder === "VSO") {
-    tokens.push(keywordToken);
-    for (const role of sortedRoles) {
-      addRoleWithMarker(tokens, role, profile);
-    }
-  } else {
-    tokens.push(keywordToken);
-    for (const role of sortedRoles) {
-      addRoleWithMarker(tokens, role, profile);
-    }
-  }
-  return tokens;
-}
-function addRoleWithMarker(tokens, roleSpec, profile) {
-  const marker = getMarkerForRole(roleSpec, profile);
-  const isOptional = !roleSpec.required;
-  const roleToken = {
-    type: "role",
-    role: roleSpec.role,
-    optional: isOptional,
-    expectedTypes: roleSpec.expectedTypes,
-    ...roleSpec.greedy && { greedy: true }
+// 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;
   };
-  if (marker) {
-    const markerInfo = profile.roleMarkers?.[roleSpec.role];
-    const defaultPosition = profile.wordOrder === "SOV" ? "after" : "before";
-    const position = roleSpec.markerPosition ?? markerInfo?.position ?? defaultPosition;
-    if (isOptional) {
-      if (position === "before") {
-        tokens.push({
-          type: "group",
-          optional: true,
-          tokens: [{ type: "literal", value: marker }, roleToken]
-        });
-      } else {
-        tokens.push({
-          type: "group",
-          optional: true,
-          tokens: [roleToken, { type: "literal", value: marker }]
-        });
+  for (const token of pattern.template.tokens) {
+    if (token.type === "role") {
+      maxScore += 1;
+      if (captured.has(token.role)) {
+        score += 1;
       }
-    } else {
-      if (position === "before") {
-        tokens.push({ type: "literal", value: marker });
-        tokens.push(roleToken);
-      } else {
-        tokens.push(roleToken);
-        tokens.push({ type: "literal", value: marker });
+    } 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;
+          }
+        }
       }
     }
-  } else {
-    tokens.push(roleToken);
-  }
-}
-function getMarkerForRole(roleSpec, profile) {
-  if (roleSpec.markerOverride?.[profile.code]) {
-    return roleSpec.markerOverride[profile.code];
-  }
-  return profile.roleMarkers?.[roleSpec.role]?.primary;
-}
-function sortRolesByWordOrder(roles, wordOrder) {
-  const sorted = [...roles];
-  if (wordOrder === "SVO") {
-    sorted.sort((a, b) => (b.svoPosition ?? 0) - (a.svoPosition ?? 0));
-  } else if (wordOrder === "SOV") {
-    sorted.sort((a, b) => (b.sovPosition ?? 0) - (a.sovPosition ?? 0));
   }
-  return sorted;
-}
-function buildExtractionRules(schema, profile) {
-  const rules = {};
-  for (const roleSpec of schema.roles) {
-    const marker = getMarkerForRole(roleSpec, profile);
-    const rule = {
-      ...roleSpec.default !== void 0 && { default: roleSpec.default },
-      ...marker && { marker }
-    };
-    rules[roleSpec.role] = rule;
+  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);
   }
-  return rules;
+  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 buildFormatString(schema, profile, keyword) {
-  const isSOV = profile.wordOrder === "SOV";
-  const preVerb = [];
-  const postVerb = [];
-  const sortedRoles = sortRolesByWordOrder(schema.roles, profile.wordOrder);
-  for (const role of sortedRoles) {
-    const marker = getMarkerForRole(role, profile);
-    const roleName = `{${role.role}}`;
-    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
-    if (marker) {
-      const markerInfo = profile.roleMarkers?.[role.role];
-      if (markerInfo?.position === "after") {
-        bucket.push(`${roleName} ${marker}`);
-      } else {
-        bucket.push(`${marker} ${roleName}`);
-      }
-    } else {
-      bucket.push(roleName);
-    }
+function calculateVSOConfidenceBoost(pattern) {
+  if (pattern.language !== "ar") {
+    return 0;
   }
-  return (isSOV ? [...preVerb, keyword, ...postVerb] : [keyword, ...preVerb, ...postVerb]).join(
-    " "
-  );
-}
-function generatePatternVariants(schema, profile, config = defaultConfig) {
-  const patterns = [];
-  patterns.push(generatePattern(schema, profile, config));
-  return patterns;
-}
-
-// src/generation/renderer.ts
-function lookupKeyword(keywords, action, language) {
-  return keywords[action]?.[language] ?? action;
-}
-function lookupMarker(markers, marker, language) {
-  return markers[marker]?.[language] ?? marker;
-}
-function buildPhrase(...parts) {
-  return parts.filter(Boolean).join(" ");
-}
-function buildTablesFromProfiles(schemas, profiles) {
-  const keywords = {};
-  const markers = {};
-  for (const profile of profiles) {
-    for (const [action, kw] of Object.entries(profile.keywords)) {
-      if (!keywords[action]) keywords[action] = {};
-      keywords[action][profile.code] = kw.primary;
-    }
+  const firstToken = pattern.template.tokens[0];
+  if (!firstToken || firstToken.type !== "literal") {
+    return 0;
   }
-  for (const schema of schemas) {
-    for (const role of schema.roles) {
-      if (role.markerOverride) {
-        const markerKey = role.role;
-        if (!markers[markerKey]) markers[markerKey] = {};
-        for (const [lang, markerText] of Object.entries(role.markerOverride)) {
-          markers[markerKey][lang] = markerText;
-        }
-      }
-    }
+  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;
   }
-  for (const profile of profiles) {
-    if (profile.roleMarkers) {
-      for (const [markerKey, markerDef] of Object.entries(profile.roleMarkers)) {
-        if (!markers[markerKey]) markers[markerKey] = {};
-        markers[markerKey][profile.code] = markerDef.primary;
+  if (firstToken.alternatives) {
+    for (const alt of firstToken.alternatives) {
+      if (ARABIC_VERBS.has(alt)) {
+        return 0.15;
       }
     }
   }
-  return { keywords, markers };
+  return 0;
 }
-function detectWordOrders(profiles) {
-  const sovLanguages = /* @__PURE__ */ new Set();
-  const vsoLanguages = /* @__PURE__ */ new Set();
-  for (const profile of profiles) {
-    if (profile.wordOrder === "SOV") sovLanguages.add(profile.code);
-    if (profile.wordOrder === "VSO") vsoLanguages.add(profile.code);
+function arabicPrepositionDisambiguation(pattern, captured) {
+  if (pattern.language !== "ar") {
+    return 0;
   }
-  return { sovLanguages, vsoLanguages };
-}
-function createSchemaRenderer(schemas, profiles) {
-  const tables = buildRenderTables(schemas, profiles);
-  return {
-    render(node, language) {
-      return renderFromSchema(node, language, tables) ?? node.action;
-    }
-  };
-}
-function createDomainRenderer(config) {
-  const { schemas, profiles, overrides } = config;
-  let tables;
-  return (node, language) => {
-    const override = overrides?.[node.action];
-    if (override) return override(node, language);
-    tables ?? (tables = buildRenderTables(schemas, profiles));
-    return renderFromSchema(node, language, tables);
+  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)
   };
-}
-function buildRenderTables(schemas, profiles) {
-  const { keywords, markers } = buildTablesFromProfiles(schemas, profiles);
-  const { sovLanguages } = detectWordOrders(profiles);
-  const markerPositions = {};
-  for (const profile of profiles) {
-    for (const [role, markerDef] of Object.entries(profile.roleMarkers ?? {})) {
-      if (!markerDef.position) continue;
-      markerPositions[role] ?? (markerPositions[role] = {});
-      markerPositions[role][profile.code] = markerDef.position;
-    }
-  }
-  const schemaMap = /* @__PURE__ */ new Map();
-  for (const s of schemas) schemaMap.set(s.action, s);
-  return { keywords, markers, markerPositions, sovLanguages, schemaMap };
-}
-function renderFromSchema(node, language, tables) {
-  const schema = tables.schemaMap.get(node.action);
-  if (!schema) return null;
-  const keyword = lookupKeyword(tables.keywords, node.action, language);
-  const isSOV = tables.sovLanguages.has(language);
-  const ordered = sortRolesByWordOrder([...schema.roles], isSOV ? "SOV" : "SVO");
-  const preVerb = [];
-  const postVerb = [];
-  for (const role of ordered) {
-    let value = extractRoleValue(node, role.role);
-    if (!value && role.default !== void 0) {
-      value = String(extractValue(role.default));
-    }
-    if (!value) continue;
-    if (role.quoteMultiword && /\s/.test(value) && !/^(["']).*\1$/.test(value)) {
-      value = `"${value}"`;
+  for (const [role, value] of captured.entries()) {
+    const preferred = PREFERRED_PREPOSITIONS[role];
+    if (!preferred || preferred.length === 0) {
+      continue;
     }
-    const markerText = role.renderOverride?.[language] ?? role.markerOverride?.[language] ?? role.renderOverride?.["*"] ?? tables.markers[role.role]?.[language];
-    const markerPosition = role.markerPositionOverride?.[language] ?? role.markerPosition ?? tables.markerPositions[role.role]?.[language] ?? (isSOV ? "after" : "before");
-    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
-    if (markerText && markerPosition === "before") {
-      bucket.push(markerText, value);
-    } else if (markerText) {
-      bucket.push(value, markerText);
-    } else {
-      bucket.push(value);
+    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 isSOV ? buildPhrase(...preVerb, keyword, ...postVerb) : buildPhrase(keyword, ...preVerb, ...postVerb);
+  return Math.max(-0.1, Math.min(0.1, adjustment));
 }
+var stockConfidenceModel = {
+  calculate: (ctx) => scoreParts(ctx).final,
+  calculateWithBreakdown: (ctx) => scoreParts(ctx)
+};
 
 // src/generation/schema-patterns.ts
 function createSchemaPatternGenerator(grammar) {
   return {
-    generatePattern: (schema, profile, config) => generatePattern2(grammar, schema, profile, config),
+    generatePattern: (schema, profile, config) => generatePattern(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) => generatePatternVariants2(grammar, schema, profile, config),
+    generatePatternVariants: (schema, profile, config) => generatePatternVariants(grammar, schema, profile, config),
     buildRoleToken
   };
 }
@@ -2088,21 +1248,21 @@ function schemaMarkerAlternatives(roleSpec, languageCode, marker) {
   const alternatives = [.../* @__PURE__ */ new Set([...legacy, ...variants])].filter((a) => a && a !== marker);
   return alternatives.length ? alternatives : void 0;
 }
-var defaultConfig2 = {
+var defaultConfig = {
   basePriority: 100,
   generateSimpleVariants: true,
   generateAlternatives: true
 };
-function generatePattern2(grammar, schema, profile, config = defaultConfig2) {
+function generatePattern(grammar, schema, profile, config = defaultConfig) {
   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 tokens = buildTokens(grammar, schema, profile, keyword);
   const extraction = buildExtractionRulesWithDefaults(schema, profile);
-  const format = buildFormatString2(grammar, schema, profile, keyword);
+  const format = buildFormatString(grammar, schema, profile, keyword);
   return {
     id,
     language: profile.code,
@@ -2115,7 +1275,7 @@ function generatePattern2(grammar, schema, profile, config = defaultConfig2) {
     extraction
   };
 }
-function generateSimplePattern(grammar, schema, profile, config = defaultConfig2) {
+function generateSimplePattern(grammar, schema, profile, config = defaultConfig) {
   const optionalRoles = schema.roles.filter((r) => !r.required);
   if (optionalRoles.length === 0) {
     return null;
@@ -2125,7 +1285,7 @@ function generateSimplePattern(grammar, schema, profile, config = defaultConfig2
     ...schema,
     roles: requiredRoles
   };
-  const pattern = generatePattern2(grammar, simpleSchema, profile, config);
+  const pattern = generatePattern(grammar, simpleSchema, profile, config);
   return {
     ...pattern,
     id: `${schema.action}-${profile.code}-generated-simple`,
@@ -2134,7 +1294,7 @@ function generateSimplePattern(grammar, schema, profile, config = defaultConfig2
     extraction: buildExtractionRulesWithDefaults(schema, profile)
   };
 }
-function generateVerbFirstPattern(schema, profile, config = defaultConfig2) {
+function generateVerbFirstPattern(schema, profile, config = defaultConfig) {
   if (profile.wordOrder !== "SOV") return null;
   const requiredRoles = schema.roles.filter((r) => r.required);
   if (requiredRoles.length !== 1) return null;
@@ -2143,11 +1303,13 @@ function generateVerbFirstPattern(schema, profile, config = defaultConfig2) {
   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
+      expectedTypes: r.expectedTypes,
+      ...words ? { words } : {}
     };
     return prefix ? [{ type: "literal", value: prefix }, roleToken] : [roleToken];
   });
@@ -2165,11 +1327,11 @@ function generateVerbFirstPattern(schema, profile, config = defaultConfig2) {
     extraction: buildExtractionRulesWithDefaults(schema, profile)
   };
 }
-function generatePatternVariants2(grammar, schema, profile, config = defaultConfig2) {
+function generatePatternVariants(grammar, schema, profile, config = defaultConfig) {
   const patterns = [];
   const full = schema;
   schema = withoutVariantOnlyRoles(schema);
-  patterns.push(generatePattern2(grammar, schema, profile, config));
+  patterns.push(generatePattern(grammar, schema, profile, config));
   if (config.generateSimpleVariants) {
     const simple = generateSimplePattern(grammar, schema, profile, config);
     if (simple) {
@@ -2181,7 +1343,7 @@ function generatePatternVariants2(grammar, schema, profile, config = defaultConf
       ...schema,
       roles: schema.roles.filter((r) => r.role !== omitted)
     };
-    const variant = generatePattern2(grammar, variantSchema, profile, config);
+    const variant = generatePattern(grammar, variantSchema, profile, config);
     patterns.push({
       ...variant,
       id: `${schema.action}-${profile.code}-generated-no-${omitted}`,
@@ -2196,7 +1358,7 @@ function generatePatternVariants2(grammar, schema, profile, config = defaultConf
         (r) => r.role === widen.role ? { ...r, expectedTypes: [...widen.types] } : r
       )
     };
-    const main = generatePattern2(grammar, cloneSchema, profile, config);
+    const main = generatePattern(grammar, cloneSchema, profile, config);
     patterns.push({
       ...main,
       id: `${schema.action}-${profile.code}-generated-${widen.idSuffix}`,
@@ -2211,7 +1373,7 @@ function generatePatternVariants2(grammar, schema, profile, config = defaultConf
         return r.role === v.widen?.role ? { ...required, expectedTypes: [...v.widen.types] } : required;
       })
     };
-    const variant = generatePattern2(grammar, variantSchema, profile, config);
+    const variant = generatePattern(grammar, variantSchema, profile, config);
     patterns.push({
       ...variant,
       id: `${schema.action}-${profile.code}-generated-${v.idSuffix}`,
@@ -2236,7 +1398,7 @@ function generatePatternVariants2(grammar, schema, profile, config = defaultConf
     };
     const delta = v.priorityDelta ?? 5;
     const carrier = v.methodCarrier ? { [v.methodCarrier]: { value: literal } } : {};
-    const main = generatePattern2(grammar, cloneSchema, profile, config);
+    const main = generatePattern(grammar, cloneSchema, profile, config);
     patterns.push({
       ...main,
       id: `${schema.action}-${profile.code}-generated-${v.idSuffix}`,
@@ -2257,7 +1419,7 @@ function generatePatternVariants2(grammar, schema, profile, config = defaultConf
   }
   return patterns;
 }
-function buildTokens2(grammar, schema, profile, keyword) {
+function buildTokens(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") : [];
@@ -2317,11 +1479,17 @@ function buildRoleTokens(grammar, schema, profile) {
   }
   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,
@@ -2333,7 +1501,9 @@ function buildRoleToken(roleSpec, profile) {
     ...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 } : {}
+    ...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 = () => {
@@ -2403,7 +1573,7 @@ function buildRoleToken(roleSpec, profile) {
   }
   return tokens;
 }
-function buildExtractionRules2(schema, profile) {
+function buildExtractionRules(schema, profile) {
   const rules = {};
   for (const roleSpec of schema.roles) {
     const overrideMarker = roleSpec.markerOverride?.[profile.code];
@@ -2433,7 +1603,7 @@ function buildExtractionRules2(schema, profile) {
   return rules;
 }
 function buildExtractionRulesWithDefaults(schema, profile) {
-  const baseRules = buildExtractionRules2(schema, profile);
+  const baseRules = buildExtractionRules(schema, profile);
   const rules = {};
   for (const roleSpec of schema.roles) {
     const baseRule = baseRules[roleSpec.role] || {};
@@ -2445,7 +1615,7 @@ function buildExtractionRulesWithDefaults(schema, profile) {
   }
   return rules;
 }
-function buildFormatString2(grammar, schema, profile, keyword) {
+function buildFormatString(grammar, schema, profile, keyword) {
   const parts = [];
   const sortedRoles = sortRolesByPosition(schema.roles, profile.wordOrder, grammar.positionOrder);
   const roleParts = sortedRoles.map((roleSpec) => {
@@ -3889,12 +3059,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";
   }
@@ -4013,15 +3186,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",
@@ -4245,21 +3435,14 @@ function createMultilingualDSL(config) {
   return new MultilingualDSLImpl(effectiveConfig, registry, transformer, profileProvider, engine);
 }
 function engineFor(config) {
-  const name = config.engine ?? "classic";
-  if (name === "classic") return classicEngine();
+  const name = config.engine ?? "core";
   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)
-    })
-  };
+  if (name === "classic") {
+    throw new Error(
+      'The "classic" DSL engine was removed in @lokascript/framework 5.0. Omit `engine` (or pass "core"): every domain reads on the core.'
+    );
+  }
+  throw new Error(`Unknown DSL engine "${name}" (expected "core")`);
 }
 function schemaProfileOf(profile) {
   const side = profile.wordOrder === "SOV" ? "after" : "before";
@@ -5947,6 +5130,130 @@ async function registryToAOTBackends(registry) {
 // src/schema/command-schema.ts
 import { defineCommand, defineRole, getRoleSpec } from "@lokascript/intent";
 
+// src/generation/profile.ts
+function sortRolesByWordOrder(roles, wordOrder) {
+  const sorted = [...roles];
+  if (wordOrder === "SVO") {
+    sorted.sort((a, b) => (b.svoPosition ?? 0) - (a.svoPosition ?? 0));
+  } else if (wordOrder === "SOV") {
+    sorted.sort((a, b) => (b.sovPosition ?? 0) - (a.sovPosition ?? 0));
+  }
+  return sorted;
+}
+
+// src/generation/renderer.ts
+function lookupKeyword(keywords, action, language) {
+  return keywords[action]?.[language] ?? action;
+}
+function lookupMarker(markers, marker, language) {
+  return markers[marker]?.[language] ?? marker;
+}
+function buildPhrase(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function buildTablesFromProfiles(schemas, profiles) {
+  const keywords = {};
+  const markers = {};
+  for (const profile of profiles) {
+    for (const [action, kw] of Object.entries(profile.keywords)) {
+      if (!keywords[action]) keywords[action] = {};
+      keywords[action][profile.code] = kw.primary;
+    }
+  }
+  for (const schema of schemas) {
+    for (const role of schema.roles) {
+      if (role.markerOverride) {
+        const markerKey = role.role;
+        if (!markers[markerKey]) markers[markerKey] = {};
+        for (const [lang, markerText] of Object.entries(role.markerOverride)) {
+          markers[markerKey][lang] = markerText;
+        }
+      }
+    }
+  }
+  for (const profile of profiles) {
+    if (profile.roleMarkers) {
+      for (const [markerKey, markerDef] of Object.entries(profile.roleMarkers)) {
+        if (!markers[markerKey]) markers[markerKey] = {};
+        markers[markerKey][profile.code] = markerDef.primary;
+      }
+    }
+  }
+  return { keywords, markers };
+}
+function detectWordOrders(profiles) {
+  const sovLanguages = /* @__PURE__ */ new Set();
+  const vsoLanguages = /* @__PURE__ */ new Set();
+  for (const profile of profiles) {
+    if (profile.wordOrder === "SOV") sovLanguages.add(profile.code);
+    if (profile.wordOrder === "VSO") vsoLanguages.add(profile.code);
+  }
+  return { sovLanguages, vsoLanguages };
+}
+function createSchemaRenderer(schemas, profiles) {
+  const tables = buildRenderTables(schemas, profiles);
+  return {
+    render(node, language) {
+      return renderFromSchema(node, language, tables) ?? node.action;
+    }
+  };
+}
+function createDomainRenderer(config) {
+  const { schemas, profiles, overrides } = config;
+  let tables;
+  return (node, language) => {
+    const override = overrides?.[node.action];
+    if (override) return override(node, language);
+    tables ?? (tables = buildRenderTables(schemas, profiles));
+    return renderFromSchema(node, language, tables);
+  };
+}
+function buildRenderTables(schemas, profiles) {
+  const { keywords, markers } = buildTablesFromProfiles(schemas, profiles);
+  const { sovLanguages } = detectWordOrders(profiles);
+  const markerPositions = {};
+  for (const profile of profiles) {
+    for (const [role, markerDef] of Object.entries(profile.roleMarkers ?? {})) {
+      if (!markerDef.position) continue;
+      markerPositions[role] ?? (markerPositions[role] = {});
+      markerPositions[role][profile.code] = markerDef.position;
+    }
+  }
+  const schemaMap = /* @__PURE__ */ new Map();
+  for (const s of schemas) schemaMap.set(s.action, s);
+  return { keywords, markers, markerPositions, sovLanguages, schemaMap };
+}
+function renderFromSchema(node, language, tables) {
+  const schema = tables.schemaMap.get(node.action);
+  if (!schema) return null;
+  const keyword = lookupKeyword(tables.keywords, node.action, language);
+  const isSOV = tables.sovLanguages.has(language);
+  const ordered = sortRolesByWordOrder([...schema.roles], isSOV ? "SOV" : "SVO");
+  const preVerb = [];
+  const postVerb = [];
+  for (const role of ordered) {
+    let value = extractRoleValue(node, role.role);
+    if (!value && role.default !== void 0) {
+      value = String(extractValue(role.default));
+    }
+    if (!value) continue;
+    if (role.quoteMultiword && /\s/.test(value) && !/^(["']).*\1$/.test(value)) {
+      value = `"${value}"`;
+    }
+    const markerText = role.renderOverride?.[language] ?? role.markerOverride?.[language] ?? role.renderOverride?.["*"] ?? tables.markers[role.role]?.[language];
+    const markerPosition = role.markerPositionOverride?.[language] ?? role.markerPosition ?? tables.markerPositions[role.role]?.[language] ?? (isSOV ? "after" : "before");
+    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
+    if (markerText && markerPosition === "before") {
+      bucket.push(markerText, value);
+    } else if (markerText) {
+      bucket.push(value, markerText);
+    } else {
+      bucket.push(value);
+    }
+  }
+  return isSOV ? buildPhrase(...preVerb, keyword, ...postVerb) : buildPhrase(keyword, ...preVerb, ...postVerb);
+}
+
 // src/generation/diagnostics.ts
 import { createDiagnosticCollector, fromError, filterBySeverity } from "@lokascript/intent";
 
@@ -7800,7 +7107,6 @@ export {
   NullProfileProvider,
   NumberExtractor,
   OperatorExtractor,
-  PatternMatcher,
   PatternTracker,
   PunctuationExtractor,
   StockValueReader,
@@ -7864,8 +7170,6 @@ export {
   fromInterchangeNode,
   fromProtocolJSON,
   generateExamples,
-  generatePattern,
-  generatePatternVariants,
   generatePrompt,
   generateProtocolReference,
   getAllPossessiveKeywords,
@@ -7904,8 +7208,6 @@ export {
   legacyMarkerAlternatives,
   lookupKeyword,
   lookupMarker,
-  matchBest,
-  matchPattern,
   needsDisambiguation,
   noChange,
   normalized,
@@ -7913,7 +7215,6 @@ export {
   parseDocument,
   parseExplicit,
   parseJSONL,
-  patternMatcher,
   readGreedy,
   readRoleValue,
   registryToAOTBackends,