@lokascript/framework 2.0.0

package/dist/index.js

@@ -0,0 +1,4336 @@
+// src/core/types.ts
+function createLiteral(value, dataType) {
+  return dataType ? { type: "literal", value, dataType } : { type: "literal", value };
+}
+function createSelector(value, selectorKind) {
+  return selectorKind ? { type: "selector", value, selectorKind } : { type: "selector", value };
+}
+function createReference(value) {
+  return { type: "reference", value };
+}
+function createPropertyPath(object, property) {
+  return { type: "property-path", object, property };
+}
+function createExpression(raw) {
+  return { type: "expression", raw };
+}
+function createCommandNode(action, roles, metadata) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const node = {
+    kind: "command",
+    action,
+    roles: rolesMap
+  };
+  if (metadata) {
+    return { ...node, metadata };
+  }
+  return node;
+}
+function createEventHandlerNode(action, roles, body, metadata, eventModifiers) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const base = {
+    kind: "event-handler",
+    action,
+    roles: rolesMap,
+    body
+  };
+  return {
+    ...base,
+    ...eventModifiers && { eventModifiers },
+    ...metadata && { metadata }
+  };
+}
+function createConditionalNode(action, roles, thenBranch, elseBranch, metadata) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const base = {
+    kind: "conditional",
+    action,
+    roles: rolesMap,
+    thenBranch
+  };
+  return {
+    ...base,
+    ...elseBranch && { elseBranch },
+    ...metadata && { metadata }
+  };
+}
+function createCompoundNode(statements, chainType = "sequential", metadata) {
+  const base = {
+    kind: "compound",
+    action: "compound",
+    roles: /* @__PURE__ */ new Map(),
+    statements,
+    chainType
+  };
+  return metadata ? { ...base, metadata } : base;
+}
+function extractValue(value) {
+  if ("raw" in value && value.raw !== void 0) return String(value.raw);
+  if ("value" in value && value.value !== void 0) return String(value.value);
+  if (value.type === "property-path") return `${extractValue(value.object)}.${value.property}`;
+  return "";
+}
+function extractRoleValue(node, role) {
+  const value = node.roles.get(role);
+  if (!value) return "";
+  return extractValue(value);
+}
+function createLoopNode(action, roles, loopVariant, body, loopVariable, indexVariable, metadata) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const base = {
+    kind: "loop",
+    action,
+    roles: rolesMap,
+    loopVariant,
+    body
+  };
+  return {
+    ...base,
+    ...loopVariable && { loopVariable },
+    ...indexVariable && { indexVariable },
+    ...metadata && { metadata }
+  };
+}
+
+// src/core/logger.ts
+var DebugLogger = class {
+  constructor(namespace) {
+    this.namespace = namespace;
+    this.enabled = this.checkEnabled();
+  }
+  checkEnabled() {
+    if (typeof process !== "undefined" && process.env) {
+      const DEBUG = process.env.DEBUG || "";
+      return DEBUG === "*" || DEBUG.includes("framework:*") || DEBUG.includes(`framework:${this.namespace}`);
+    }
+    return false;
+  }
+  log(level, message, ...args) {
+    if (!this.enabled) return;
+    const prefix = `[framework:${this.namespace}]`;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    switch (level) {
+      case "debug":
+        console.debug(`${timestamp} ${prefix} DEBUG:`, message, ...args);
+        break;
+      case "info":
+        console.info(`${timestamp} ${prefix} INFO:`, message, ...args);
+        break;
+      case "warn":
+        console.warn(`${timestamp} ${prefix} WARN:`, message, ...args);
+        break;
+      case "error":
+        console.error(`${timestamp} ${prefix} ERROR:`, message, ...args);
+        break;
+    }
+  }
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+  /**
+   * Check if logging is enabled for this namespace.
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Programmatically enable logging for this namespace.
+   */
+  enable() {
+    this.enabled = true;
+  }
+  /**
+   * Programmatically disable logging for this namespace.
+   */
+  disable() {
+    this.enabled = false;
+  }
+};
+function createLogger(namespace) {
+  return new DebugLogger(namespace);
+}
+
+// src/core/pattern-matching/utils/type-validation.ts
+function isTypeCompatible(actualType, expectedTypes) {
+  if (!expectedTypes || expectedTypes.length === 0) {
+    return true;
+  }
+  if (expectedTypes.includes(actualType)) {
+    return true;
+  }
+  if (expectedTypes.includes("expression")) {
+    return true;
+  }
+  if (actualType === "property-path") {
+    return expectedTypes.some((t) => ["selector", "reference", "expression"].includes(t));
+  }
+  return false;
+}
+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/pattern-matching/utils/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/pattern-matching/pattern-matcher.ts
+function isValidReference(_value) {
+  return false;
+}
+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;
+  }
+  /**
+   * Safely convert a value to lowercase string.
+   * Provides protection against non-string values at runtime.
+   */
+  safeToLowerCase(value) {
+    if (typeof value === "string") {
+      return value.toLowerCase();
+    }
+    if (value === null || value === void 0) {
+      return "";
+    }
+    return String(value).toLowerCase();
+  }
+  /**
+   * Try to match a single pattern against the token stream.
+   * Returns the match result or null if no match.
+   *
+   * @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 = this.calculateConfidence(pattern, captured);
+    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) {
+    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);
+        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;
+        }
+      }
+      const isOptionalRole = patternToken.type === "role" && patternToken.optional === true;
+      const markBefore = isOptionalRole ? tokens.mark() : null;
+      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 this.matchRoleToken(tokens, patternToken, captured);
+      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 role pattern token (captures a semantic value).
+   * Handles multi-token expressions like:
+   * - 'my value' (possessive keyword + property)
+   * - '#dialog.showModal()' (method call)
+   * - "#element's *opacity" (possessive selector + property)
+   */
+  matchRoleToken(tokens, patternToken, captured) {
+    this.logger.debug("    >>> matchRoleToken ENTRY: capturing role", patternToken.role);
+    this.logger.debug("    >>> matchRoleToken: expected types", patternToken.expectedTypes);
+    this.logger.debug("    >>> matchRoleToken: optional?", patternToken.optional);
+    this.skipNoiseWords(tokens);
+    const token = tokens.peek();
+    this.logger.debug(
+      "    >>> After skipNoiseWords, current token:",
+      token ? JSON.stringify({ value: token.value, kind: token.kind }) : "null"
+    );
+    if (!token) {
+      return patternToken.optional || false;
+    }
+    const possessiveValue = this.tryMatchPossessiveExpression(tokens);
+    if (possessiveValue) {
+      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+        if (!patternToken.expectedTypes.includes(possessiveValue.type) && !patternToken.expectedTypes.includes("expression")) {
+          return patternToken.optional || false;
+        }
+      }
+      captured.set(patternToken.role, possessiveValue);
+      return true;
+    }
+    const methodCallValue = this.tryMatchMethodCallExpression(tokens);
+    if (methodCallValue) {
+      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+        if (!patternToken.expectedTypes.includes(methodCallValue.type) && !patternToken.expectedTypes.includes("expression")) {
+          return patternToken.optional || false;
+        }
+      }
+      captured.set(patternToken.role, methodCallValue);
+      return true;
+    }
+    const possessiveSelectorValue = this.tryMatchPossessiveSelectorExpression(tokens);
+    if (possessiveSelectorValue) {
+      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+        if (!isTypeCompatible(possessiveSelectorValue.type, patternToken.expectedTypes)) {
+          return patternToken.optional || false;
+        }
+      }
+      captured.set(patternToken.role, possessiveSelectorValue);
+      return true;
+    }
+    const propertyAccessValue = this.tryMatchPropertyAccessExpression(tokens);
+    if (propertyAccessValue) {
+      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+        if (!patternToken.expectedTypes.includes(propertyAccessValue.type) && !patternToken.expectedTypes.includes("expression")) {
+          return patternToken.optional || false;
+        }
+      }
+      captured.set(patternToken.role, propertyAccessValue);
+      return true;
+    }
+    const selectorPropertyValue = this.tryMatchSelectorPropertyExpression(tokens);
+    if (selectorPropertyValue) {
+      if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+        if (!isTypeCompatible(selectorPropertyValue.type, patternToken.expectedTypes)) {
+          return patternToken.optional || false;
+        }
+      }
+      captured.set(patternToken.role, selectorPropertyValue);
+      return true;
+    }
+    this.logger.debug(
+      "    >>> Trying tokenToSemanticValue for token:",
+      token ? JSON.stringify({ value: token.value, kind: token.kind }) : "null"
+    );
+    const value = this.tokenToSemanticValue(token);
+    this.logger.debug(
+      "    >>> tokenToSemanticValue returned:",
+      value ? JSON.stringify(value) : "null"
+    );
+    if (!value) {
+      return patternToken.optional || false;
+    }
+    this.logger.debug(
+      "    >>> Validating type:",
+      value.type,
+      "against expected:",
+      patternToken.expectedTypes
+    );
+    if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
+      if (!isTypeCompatible(value.type, patternToken.expectedTypes)) {
+        this.logger.debug("    >>> TYPE MISMATCH - returning", patternToken.optional || false);
+        return patternToken.optional || false;
+      }
+    }
+    this.logger.debug("    >>> Type validation PASSED");
+    captured.set(patternToken.role, value);
+    tokens.advance();
+    return true;
+  }
+  /**
+   * Try to match a possessive expression like 'my value' or 'its innerHTML'.
+   * Returns the PropertyPathValue if matched, or null if not.
+   */
+  tryMatchPossessiveExpression(tokens) {
+    const token = tokens.peek();
+    if (!token) return null;
+    if (!this.currentProfile) return null;
+    const tokenValue = token.normalized || token.value;
+    const tokenLower = this.safeToLowerCase(tokenValue);
+    const baseRef = getPossessiveReference(this.currentProfile, tokenLower);
+    if (!baseRef) return null;
+    const mark = tokens.mark();
+    tokens.advance();
+    const propertyToken = tokens.peek();
+    if (!propertyToken) {
+      tokens.reset(mark);
+      return null;
+    }
+    if (propertyToken.kind === "identifier" || propertyToken.kind === "keyword" && !this.isStructuralKeyword(propertyToken.value) || propertyToken.kind === "selector" && propertyToken.value.startsWith("*") || propertyToken.kind === "selector" && propertyToken.value.startsWith("@") || propertyToken.kind === "selector" && propertyToken.value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyToken.value)) {
+      tokens.advance();
+      let propertyName = propertyToken.value;
+      if (propertyToken.kind === "selector" && propertyName.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(propertyName)) {
+        propertyName = propertyName.substring(1);
+      }
+      let chainedProps = propertyName;
+      while (tokens.peek()?.kind === "selector" && tokens.peek().value.startsWith(".") && /^\.[a-zA-Z_]\w*/.test(tokens.peek().value)) {
+        chainedProps += tokens.peek().value;
+        tokens.advance();
+      }
+      const nextPeek = tokens.peek();
+      if (nextPeek?.kind === "literal" && nextPeek.value.startsWith("(")) {
+        chainedProps += nextPeek.value;
+        tokens.advance();
+      }
+      return createPropertyPath(createReference(baseRef), chainedProps);
+    }
+    tokens.reset(mark);
+    return null;
+  }
+  /**
+   * Check if a keyword is a structural keyword (preposition, control flow, etc.)
+   * that shouldn't be consumed as a property name.
+   */
+  isStructuralKeyword(value) {
+    const structural = /* @__PURE__ */ new Set([
+      // Prepositions
+      "into",
+      "in",
+      "to",
+      "from",
+      "at",
+      "by",
+      "with",
+      "without",
+      "before",
+      "after",
+      "of",
+      "as",
+      "on",
+      // Control flow
+      "then",
+      "end",
+      "else",
+      "if",
+      "repeat",
+      "while",
+      "for",
+      // Commands (shouldn't be property names)
+      "toggle",
+      "add",
+      "remove",
+      "put",
+      "set",
+      "show",
+      "hide",
+      "increment",
+      "decrement",
+      "send",
+      "trigger",
+      "call"
+    ]);
+    return structural.has(value.toLowerCase());
+  }
+  /**
+   * Try to match a method call expression like '#dialog.showModal()'.
+   * Pattern: selector + '.' + identifier + '(' + [args] + ')'
+   * Returns an expression value if matched, or null if not.
+   */
+  tryMatchMethodCallExpression(tokens) {
+    const token = tokens.peek();
+    if (!token || token.kind !== "selector") return null;
+    const mark = tokens.mark();
+    tokens.advance();
+    const dotToken = tokens.peek();
+    if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
+      tokens.reset(mark);
+      return null;
+    }
+    tokens.advance();
+    const methodToken = tokens.peek();
+    if (!methodToken || methodToken.kind !== "identifier") {
+      tokens.reset(mark);
+      return null;
+    }
+    tokens.advance();
+    const openParen = tokens.peek();
+    if (!openParen || openParen.kind !== "punctuation" || openParen.value !== "(") {
+      tokens.reset(mark);
+      return null;
+    }
+    tokens.advance();
+    const args = [];
+    while (!tokens.isAtEnd() && args.length < _PatternMatcher.MAX_METHOD_ARGS) {
+      const argToken = tokens.peek();
+      if (!argToken) break;
+      if (argToken.kind === "punctuation" && argToken.value === ")") {
+        tokens.advance();
+        break;
+      }
+      if (argToken.kind === "punctuation" && argToken.value === ",") {
+        tokens.advance();
+        continue;
+      }
+      args.push(argToken.value);
+      tokens.advance();
+    }
+    const methodCall = `${token.value}.${methodToken.value}(${args.join(", ")})`;
+    return {
+      type: "expression",
+      raw: methodCall
+    };
+  }
+  /**
+   * Try to match a property access expression like 'userData.name' or 'it.data'.
+   * Pattern: (identifier | keyword) + '.' + identifier [+ '.' + identifier ...]
+   * Returns an expression value if matched, or null if not.
+   */
+  tryMatchPropertyAccessExpression(tokens) {
+    const token = tokens.peek();
+    if (!token) return null;
+    if (token.kind !== "identifier" && token.kind !== "keyword") return null;
+    const mark = tokens.mark();
+    tokens.advance();
+    const dotToken = tokens.peek();
+    if (!dotToken || dotToken.kind !== "operator" || dotToken.value !== ".") {
+      tokens.reset(mark);
+      return null;
+    }
+    tokens.advance();
+    const propertyToken = tokens.peek();
+    if (!propertyToken || propertyToken.kind !== "identifier") {
+      tokens.reset(mark);
+      return null;
+    }
+    tokens.advance();
+    let chain = `${token.value}.${propertyToken.value}`;
+    let depth = 1;
+    while (!tokens.isAtEnd() && depth < _PatternMatcher.MAX_PROPERTY_DEPTH) {
+      const nextDot = tokens.peek();
+      if (!nextDot || nextDot.kind !== "operator" || nextDot.value !== ".") {
+        break;
+      }
+      tokens.advance();
+      const nextProp = tokens.peek();
+      if (!nextProp || nextProp.kind !== "identifier") {
+        break;
+      }
+      tokens.advance();
+      chain += `.${nextProp.value}`;
+      depth++;
+    }
+    const openParen = tokens.peek();
+    if (openParen && openParen.kind === "punctuation" && openParen.value === "(") {
+      tokens.advance();
+      const args = [];
+      let argDepth = 0;
+      while (!tokens.isAtEnd() && args.length < _PatternMatcher.MAX_METHOD_ARGS) {
+        const argToken = tokens.peek();
+        if (!argToken) break;
+        if (argToken.kind === "punctuation" && argToken.value === ")") {
+          if (argDepth === 0) {
+            tokens.advance();
+            break;
+          }
+          argDepth--;
+        }
+        if (argToken.kind === "punctuation" && argToken.value === "(") {
+          argDepth++;
+        }
+        if (argToken.kind === "punctuation" && argToken.value === ",") {
+          tokens.advance();
+          continue;
+        }
+        args.push(argToken.value);
+        tokens.advance();
+      }
+      const methodCall = `${chain}(${args.join(", ")})`;
+      return {
+        type: "expression",
+        raw: methodCall
+      };
+    }
+    return {
+      type: "expression",
+      raw: chain
+    };
+  }
+  /**
+   * Try to match a possessive selector expression like "#element's *opacity".
+   * Pattern: selector + "'s" + (selector | identifier)
+   * Returns a property-path value if matched, or null if not.
+   */
+  tryMatchPossessiveSelectorExpression(tokens) {
+    const token = tokens.peek();
+    if (!token || token.kind !== "selector") return null;
+    const mark = tokens.mark();
+    tokens.advance();
+    const possessiveToken = tokens.peek();
+    if (!possessiveToken || possessiveToken.kind !== "punctuation" || possessiveToken.value !== "'s") {
+      tokens.reset(mark);
+      return null;
+    }
+    tokens.advance();
+    const propertyToken = tokens.peek();
+    if (!propertyToken) {
+      tokens.reset(mark);
+      return null;
+    }
+    if (propertyToken.kind !== "selector" && propertyToken.kind !== "identifier") {
+      tokens.reset(mark);
+      return null;
+    }
+    tokens.advance();
+    return createPropertyPath(createSelector(token.value), propertyToken.value);
+  }
+  /**
+   * Try to match a selector + property expression like "#output.innerText".
+   * This handles cases where the tokenizer produces two selector tokens:
+   * - #output (id selector)
+   * - .innerText (looks like class selector, but is actually property)
+   *
+   * Pattern: id-selector + class-selector-that-is-actually-property
+   * Returns a property-path value if matched, or null if not.
+   */
+  tryMatchSelectorPropertyExpression(tokens) {
+    const token = tokens.peek();
+    if (!token || token.kind !== "selector") return null;
+    if (typeof token.value !== "string" || !token.value.startsWith("#")) return null;
+    const mark = tokens.mark();
+    tokens.advance();
+    const propertyToken = tokens.peek();
+    if (!propertyToken || propertyToken.kind !== "selector") {
+      tokens.reset(mark);
+      return null;
+    }
+    if (!propertyToken.value.startsWith(".")) {
+      tokens.reset(mark);
+      return null;
+    }
+    const peek2 = tokens.peek(1);
+    if (peek2 && peek2.kind === "selector") {
+    }
+    tokens.advance();
+    const propertyName = propertyToken.value.slice(1);
+    return createPropertyPath(createSelector(token.value), propertyName);
+  }
+  /**
+   * Match a group pattern token (optional sequence).
+   * When the group's leading marker isn't at the current position, scans ahead
+   * 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) {
+    const mark = tokens.mark();
+    const capturedBefore = new Set(captured.keys());
+    const success = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+    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);
+          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" && this.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;
+          }
+        }
+        break;
+      }
+    }
+    return markers;
+  }
+  /**
+   * Check if a token matches any stop marker for greedy capture.
+   */
+  isStopMarker(token, stopMarkers) {
+    if (stopMarkers.size === 0) return false;
+    const value = (token.normalized || token.value).toLowerCase();
+    return stopMarkers.has(value);
+  }
+  /**
+   * Convert a language token to a semantic value.
+   */
+  tokenToSemanticValue(token) {
+    switch (token.kind) {
+      case "selector":
+        return createSelector(token.value);
+      case "literal":
+        return this.parseLiteralValue(token.value);
+      case "keyword":
+        const tokenValue = token.normalized || token.value;
+        const lower = this.safeToLowerCase(tokenValue);
+        if (isValidReference(lower)) {
+          return createReference(lower);
+        }
+        return createLiteral(token.normalized || token.value);
+      case "identifier":
+        if (typeof token.value === "string" && token.value.startsWith(":")) {
+          return createReference(token.value);
+        }
+        const identLower = this.safeToLowerCase(token.value);
+        if (isValidReference(identLower)) {
+          return createReference(identLower);
+        }
+        return { type: "expression", raw: token.value };
+      case "url":
+        return createLiteral(token.value, "string");
+      default:
+        return null;
+    }
+  }
+  /**
+   * Parse a literal value (string, number, boolean).
+   */
+  parseLiteralValue(value) {
+    if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
+      const inner = value.slice(1, -1);
+      return createLiteral(inner, "string");
+    }
+    if (value === "true") return createLiteral(true, "boolean");
+    if (value === "false") return createLiteral(false, "boolean");
+    const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+    if (durationMatch) {
+      const num2 = parseFloat(durationMatch[1]);
+      const unit = durationMatch[2];
+      if (unit) {
+        return createLiteral(value, "duration");
+      }
+      return createLiteral(num2, "number");
+    }
+    const num = parseFloat(value);
+    if (!isNaN(num)) {
+      return createLiteral(num, "number");
+    }
+    return createLiteral(value, "string");
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Calculate confidence score for a match (0-1).
+   *
+   * Confidence is reduced for:
+   * - Stem matches (morphological normalization has inherent uncertainty)
+   * - Missing optional roles (but less penalty if role has a default value)
+   *
+   * Confidence is increased for:
+   * - VSO languages (Arabic) when pattern starts with a verb
+   */
+  calculateConfidence(pattern, captured) {
+    let score = 0;
+    let maxScore = 0;
+    const hasDefault = (role) => {
+      return pattern.extraction?.[role]?.default !== void 0;
+    };
+    for (const token of pattern.template.tokens) {
+      if (token.type === "role") {
+        maxScore += 1;
+        if (captured.has(token.role)) {
+          score += 1;
+        }
+      } else if (token.type === "group") {
+        for (const subToken of token.tokens) {
+          if (subToken.type === "role") {
+            const roleHasDefault = hasDefault(subToken.role);
+            const weight = 0.8;
+            maxScore += weight;
+            if (captured.has(subToken.role)) {
+              score += weight;
+            } else if (roleHasDefault) {
+              score += weight * 0.6;
+            }
+          }
+        }
+      }
+    }
+    let baseConfidence = maxScore > 0 ? score / maxScore : 1;
+    if (this.stemMatchCount > 0 && this.totalKeywordMatches > 0) {
+      const stemPenalty = this.stemMatchCount / this.totalKeywordMatches * 0.15;
+      baseConfidence = Math.max(0.5, baseConfidence - stemPenalty);
+    }
+    const vsoBoost = this.calculateVSOConfidenceBoost(pattern);
+    baseConfidence = Math.min(1, baseConfidence + vsoBoost);
+    const prepositionAdjustment = this.arabicPrepositionDisambiguation(pattern, captured);
+    baseConfidence = Math.max(0, Math.min(1, baseConfidence + prepositionAdjustment));
+    return baseConfidence;
+  }
+  /**
+   * Calculate confidence boost for VSO (Verb-Subject-Object) language patterns.
+   * Arabic naturally uses VSO word order, so patterns that start with a verb
+   * should receive a confidence boost.
+   *
+   * Returns +0.15 confidence boost if:
+   * - Language is Arabic ('ar')
+   * - Pattern's first token is a verb keyword
+   *
+   * @param pattern The language pattern being matched
+   * @returns Confidence boost (0 or 0.15)
+   */
+  calculateVSOConfidenceBoost(pattern) {
+    if (pattern.language !== "ar") {
+      return 0;
+    }
+    const firstToken = pattern.template.tokens[0];
+    if (!firstToken || firstToken.type !== "literal") {
+      return 0;
+    }
+    const ARABIC_VERBS = /* @__PURE__ */ new Set([
+      "\u0628\u062F\u0644",
+      "\u063A\u064A\u0631",
+      "\u0623\u0636\u0641",
+      "\u0623\u0632\u0644",
+      "\u0636\u0639",
+      "\u0627\u062C\u0639\u0644",
+      "\u0639\u064A\u0646",
+      "\u0632\u062F",
+      "\u0627\u0646\u0642\u0635",
+      "\u0633\u062C\u0644",
+      "\u0623\u0638\u0647\u0631",
+      "\u0623\u062E\u0641",
+      "\u0634\u063A\u0644",
+      "\u0623\u0631\u0633\u0644",
+      "\u0631\u0643\u0632",
+      "\u0634\u0648\u0634",
+      "\u062A\u0648\u0642\u0641",
+      "\u0627\u0646\u0633\u062E",
+      "\u0627\u062D\u0630\u0641",
+      "\u0627\u0635\u0646\u0639",
+      "\u0627\u0646\u062A\u0638\u0631",
+      "\u0627\u0646\u062A\u0642\u0627\u0644",
+      "\u0623\u0648"
+    ]);
+    if (ARABIC_VERBS.has(firstToken.value)) {
+      return 0.15;
+    }
+    if (firstToken.alternatives) {
+      for (const alt of firstToken.alternatives) {
+        if (ARABIC_VERBS.has(alt)) {
+          return 0.15;
+        }
+      }
+    }
+    return 0;
+  }
+  /**
+   * Arabic preposition disambiguation for confidence adjustment.
+   *
+   * Different Arabic prepositions are more or less natural for different semantic roles:
+   * - على (on/upon) is preferred for patient/target roles (element selectors)
+   * - إلى (to) is preferred for destination roles
+   * - من (from) is preferred for source roles
+   * - في (in) is preferred for location roles
+   *
+   * This method analyzes the prepositions used with captured semantic roles and
+   * adjusts confidence based on idiomaticity:
+   * - +0.10 for highly idiomatic preposition choices
+   * - -0.10 for less natural preposition choices
+   *
+   * @param pattern The language pattern being matched
+   * @param captured The captured semantic values
+   * @returns Confidence adjustment (-0.10 to +0.10)
+   */
+  arabicPrepositionDisambiguation(pattern, captured) {
+    if (pattern.language !== "ar") {
+      return 0;
+    }
+    let adjustment = 0;
+    const PREFERRED_PREPOSITIONS = {
+      patient: ["\u0639\u0644\u0649"],
+      // element selectors prefer على (on/upon)
+      destination: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
+      // destination prefers إلى (to)
+      source: ["\u0645\u0646"],
+      // source prefers من (from)
+      agent: ["\u0645\u0646"],
+      // agent/by prefers من (from/by)
+      manner: ["\u0628"],
+      // manner prefers ب (with/by)
+      style: ["\u0628"],
+      // style prefers ب (with)
+      goal: ["\u0625\u0644\u0649", "\u0627\u0644\u0649"],
+      // target state prefers إلى (to)
+      method: ["\u0628"]
+      // method prefers ب (with/by)
+    };
+    for (const [role, value] of captured.entries()) {
+      const preferred = PREFERRED_PREPOSITIONS[role];
+      if (!preferred || preferred.length === 0) {
+        continue;
+      }
+      const metadata = "metadata" in value ? value.metadata : void 0;
+      if (metadata && typeof metadata.prepositionValue === "string") {
+        const usedPreposition = metadata.prepositionValue;
+        if (preferred.includes(usedPreposition)) {
+          adjustment += 0.1;
+        } else {
+          adjustment -= 0.1;
+        }
+      }
+    }
+    return Math.max(-0.1, Math.min(0.1, adjustment));
+  }
+  /**
+   * Skip noise words like "the" before selectors.
+   * This enables more natural English syntax like "toggle the .active".
+   */
+  skipNoiseWords(tokens) {
+    const token = tokens.peek();
+    if (!token) return;
+    const tokenLower = this.safeToLowerCase(token.value);
+    if (_PatternMatcher.ENGLISH_NOISE_WORDS.has(tokenLower)) {
+      const mark = tokens.mark();
+      tokens.advance();
+      const nextToken = tokens.peek();
+      if (nextToken && nextToken.kind === "selector") {
+        return;
+      }
+      tokens.reset(mark);
+    }
+    if (tokenLower === "class") {
+      tokens.advance();
+    }
+  }
+  /**
+   * 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;
+// ==========================================================================
+// Depth Limits for Expression Parsing (security hardening)
+// ==========================================================================
+/** Maximum depth for nested property access (e.g., a.b.c.d...) */
+_PatternMatcher.MAX_PROPERTY_DEPTH = 10;
+/** Maximum number of arguments in method calls */
+_PatternMatcher.MAX_METHOD_ARGS = 20;
+// ===========================================================================
+// English Idiom Support - Noise Word Handling
+// ===========================================================================
+/**
+ * Noise words that can be skipped in English for more natural syntax.
+ * - "the" before selectors: "toggle the .active" → "toggle .active"
+ * - "class" after class selectors: "add the .visible class" → "add .visible"
+ */
+_PatternMatcher.ENGLISH_NOISE_WORDS = /* @__PURE__ */ new Set(["the", "a", "an"]);
+var PatternMatcher = _PatternMatcher;
+var patternMatcher = new PatternMatcher();
+function matchPattern(tokens, pattern) {
+  return patternMatcher.matchPattern(tokens, pattern);
+}
+function matchBest(tokens, patterns) {
+  return patternMatcher.matchBest(tokens, patterns);
+}
+
+// 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") {
+    for (const role of sortedRoles) {
+      addRoleWithMarker(tokens, role, profile);
+    }
+    tokens.push(keywordToken);
+  } 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 }
+  };
+  if (marker) {
+    const markerInfo = profile.roleMarkers?.[roleSpec.role];
+    const defaultPosition = profile.wordOrder === "SOV" ? "after" : "before";
+    const position = 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 }]
+        });
+      }
+    } else {
+      if (position === "before") {
+        tokens.push({ type: "literal", value: marker });
+        tokens.push(roleToken);
+      } else {
+        tokens.push(roleToken);
+        tokens.push({ type: "literal", value: marker });
+      }
+    }
+  } 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;
+  }
+  return rules;
+}
+function buildFormatString(schema, profile, keyword) {
+  const parts = [];
+  if (profile.wordOrder === "SVO" || profile.wordOrder === "VSO") {
+    parts.push(keyword);
+  }
+  for (const role of schema.roles) {
+    const marker = getMarkerForRole(role, profile);
+    const roleName = `{${role.role}}`;
+    if (marker) {
+      const markerInfo = profile.roleMarkers?.[role.role];
+      if (markerInfo?.position === "after") {
+        parts.push(`${roleName} ${marker}`);
+      } else {
+        parts.push(`${marker} ${roleName}`);
+      }
+    } else {
+      parts.push(roleName);
+    }
+  }
+  if (profile.wordOrder === "SOV") {
+    parts.push(keyword);
+  }
+  return parts.join(" ");
+}
+function generatePatternVariants(schema, profile, config = defaultConfig) {
+  const patterns = [];
+  patterns.push(generatePattern(schema, profile, config));
+  return patterns;
+}
+
+// src/grammar/types.ts
+function reorderRoles(roles, targetOrder) {
+  const result = [];
+  const usedRoles = /* @__PURE__ */ new Set();
+  for (const role of targetOrder) {
+    const element = roles.get(role);
+    if (element) {
+      result.push(element);
+      usedRoles.add(role);
+    }
+  }
+  for (const [role, element] of roles) {
+    if (!usedRoles.has(role)) {
+      result.push(element);
+    }
+  }
+  return result;
+}
+function insertMarkers(elements, markers, adpositionType) {
+  const result = [];
+  for (const element of elements) {
+    const marker = markers.find((m) => m.role === element.role);
+    if (marker) {
+      if (adpositionType === "preposition") {
+        if (marker.form) result.push(marker.form);
+        result.push(element.translated || element.value);
+      } else if (adpositionType === "postposition") {
+        result.push(element.translated || element.value);
+        if (marker.form) result.push(marker.form);
+      } else {
+        result.push(element.translated || element.value);
+      }
+    } else {
+      result.push(element.translated || element.value);
+    }
+  }
+  return result;
+}
+function joinTokens(tokens) {
+  if (tokens.length === 0) return "";
+  let result = "";
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const nextToken = tokens[i + 1];
+    const isPrefix = token.endsWith("-");
+    const isSuffix = token.startsWith("-");
+    let displayToken = token;
+    if (isPrefix) displayToken = token.slice(0, -1);
+    if (isSuffix) displayToken = token.substring(1);
+    result += displayToken;
+    if (nextToken) {
+      const nextIsSuffix = nextToken.startsWith("-");
+      if (!isPrefix && !nextIsSuffix) {
+        result += " ";
+      }
+    }
+  }
+  return result;
+}
+
+// src/grammar/transformer.ts
+var GrammarTransformer = class {
+  constructor(config) {
+    this.dictionary = config.dictionary;
+    this.profileProvider = config.profileProvider;
+  }
+  /**
+   * Transform a statement from one language to another.
+   *
+   * @param input - Statement in source language
+   * @param fromLanguage - Source language code
+   * @param toLanguage - Target language code
+   * @returns Transformed statement in target language
+   *
+   * @throws Error if profiles not found or translation fails
+   */
+  transform(input, fromLanguage, toLanguage) {
+    const fromProfile = this.profileProvider.getProfile(fromLanguage);
+    const toProfile = this.profileProvider.getProfile(toLanguage);
+    if (!fromProfile) {
+      throw new Error(`No profile found for language: ${fromLanguage}`);
+    }
+    if (!toProfile) {
+      throw new Error(`No profile found for language: ${toLanguage}`);
+    }
+    const parsed = this.parseStatement(input, fromLanguage, fromProfile);
+    const translated = this.translateRoles(parsed, fromLanguage, toLanguage);
+    const reordered = reorderRoles(translated, toProfile.canonicalOrder);
+    const withMarkers = insertMarkers(reordered, toProfile.markers, toProfile.adpositionType);
+    return joinTokens(withMarkers);
+  }
+  /**
+   * Parse statement into semantic roles.
+   * This is a simplified generic parser - DSLs can provide custom parsers.
+   */
+  parseStatement(input, language, profile) {
+    const roles = /* @__PURE__ */ new Map();
+    const tokens = input.split(/\s+/);
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      const marker = profile.markers.find((m) => m.form === token);
+      if (marker) {
+        if (i + 1 < tokens.length) {
+          roles.set(marker.role, tokens[i + 1]);
+          i += 2;
+        } else {
+          i++;
+        }
+      } else {
+        const canonical = this.dictionary.lookup(token, language);
+        if (canonical) {
+          roles.set("action", canonical);
+        } else {
+          if (token.startsWith("#") || token.startsWith(".")) {
+            roles.set("patient", token);
+          } else {
+            roles.set("patient", token);
+          }
+        }
+        i++;
+      }
+    }
+    return roles;
+  }
+  /**
+   * Translate roles using injected dictionary.
+   * Returns a Map of ParsedElement objects expected by reorderRoles.
+   */
+  translateRoles(roles, _fromLanguage, toLanguage) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [role, value] of roles) {
+      const translated = this.dictionary.translate(value, toLanguage);
+      result.set(role, {
+        role,
+        value,
+        // Original value
+        translated: translated ?? value
+        // Translated value or original if no translation
+      });
+    }
+    return result;
+  }
+};
+
+// src/interfaces/dictionary.ts
+var InMemoryDictionary = class {
+  /**
+   * @param translations - Map of language code to canonical→localized mappings
+   *
+   * @example
+   * new InMemoryDictionary({
+   *   en: { select: 'select', insert: 'insert' },
+   *   es: { select: 'seleccionar', insert: 'insertar' },
+   *   ja: { select: '選択', insert: '挿入' }
+   * })
+   */
+  constructor(translations) {
+    this.translations = translations;
+  }
+  lookup(word, language) {
+    const langDict = this.translations[language];
+    if (!langDict) return void 0;
+    const wordLower = word.toLowerCase();
+    for (const [canonical, localized] of Object.entries(langDict)) {
+      if (localized.toLowerCase() === wordLower) {
+        return canonical;
+      }
+    }
+    return void 0;
+  }
+  translate(canonical, targetLanguage) {
+    return this.translations[targetLanguage]?.[canonical];
+  }
+  getAllTranslations(word, sourceLanguage) {
+    const canonical = this.lookup(word, sourceLanguage);
+    if (!canonical) return {};
+    const result = {};
+    for (const [lang, dict] of Object.entries(this.translations)) {
+      const translation = dict[canonical];
+      if (translation) {
+        result[lang] = translation;
+      }
+    }
+    return result;
+  }
+};
+var NullDictionary = class {
+  lookup(word, _language) {
+    return word;
+  }
+  translate(canonical, _targetLanguage) {
+    return canonical;
+  }
+  getAllTranslations(word, _sourceLanguage) {
+    return { en: word };
+  }
+};
+
+// src/interfaces/profile-provider.ts
+var InMemoryProfileProvider = class {
+  /**
+   * @param profiles - Map of language code to profile
+   *
+   * @example
+   * new InMemoryProfileProvider({
+   *   en: { code: 'en', wordOrder: 'SVO', ... },
+   *   ja: { code: 'ja', wordOrder: 'SOV', ... }
+   * })
+   */
+  constructor(profiles) {
+    this.profiles = profiles;
+  }
+  getProfile(language) {
+    return this.profiles[language];
+  }
+  getSupportedLanguages() {
+    return Object.keys(this.profiles);
+  }
+  hasLanguage(language) {
+    return language in this.profiles;
+  }
+};
+var NullProfileProvider = class {
+  getProfile(_language) {
+    return void 0;
+  }
+  getSupportedLanguages() {
+    return [];
+  }
+  hasLanguage(_language) {
+    return false;
+  }
+};
+
+// src/interfaces/value-extractor.ts
+var StringLiteralExtractor = class {
+  constructor() {
+    this.name = "string-literal";
+  }
+  canExtract(input, position) {
+    const char = input[position];
+    return char === '"' || char === "'" || char === "`" || char === "\u201C" || // Chinese double quote open "
+    char === "\u2018";
+  }
+  extract(input, position) {
+    const quote = input[position];
+    if (quote === "\u201C") {
+      let length2 = 1;
+      while (position + length2 < input.length) {
+        if (input[position + length2] === "\u201D") {
+          length2++;
+          return { value: input.substring(position, position + length2), length: length2 };
+        }
+        length2++;
+      }
+      return null;
+    }
+    if (quote === "\u2018") {
+      let length2 = 1;
+      while (position + length2 < input.length) {
+        if (input[position + length2] === "\u2019") {
+          length2++;
+          return { value: input.substring(position, position + length2), length: length2 };
+        }
+        length2++;
+      }
+      return null;
+    }
+    let length = 1;
+    let escaped = false;
+    while (position + length < input.length) {
+      const char = input[position + length];
+      if (escaped) {
+        escaped = false;
+        length++;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        length++;
+        continue;
+      }
+      if (char === quote) {
+        length++;
+        return {
+          value: input.substring(position, position + length),
+          length
+        };
+      }
+      length++;
+    }
+    return null;
+  }
+};
+var NumberExtractor = class {
+  constructor() {
+    this.name = "number";
+  }
+  canExtract(input, position) {
+    return /\d/.test(input[position]);
+  }
+  extract(input, position) {
+    let length = 0;
+    let hasDecimal = false;
+    while (position + length < input.length) {
+      const char = input[position + length];
+      if (/\d/.test(char)) {
+        length++;
+      } else if (char === "." && !hasDecimal) {
+        hasDecimal = true;
+        length++;
+      } else {
+        break;
+      }
+    }
+    if (length === 0) return null;
+    const numValue = input.substring(position, position + length);
+    const afterNum = position + length;
+    if (afterNum < input.length) {
+      const remaining = input.slice(afterNum);
+      const cjkMultiUnits = [
+        { pattern: "\u6BEB\u79D2", suffix: "ms" },
+        // Chinese milliseconds
+        { pattern: "\u5206\u949F", suffix: "m" },
+        // Chinese minutes
+        { pattern: "\u5C0F\u65F6", suffix: "h" },
+        // Chinese hours
+        { pattern: "\u30DF\u30EA\u79D2", suffix: "ms" },
+        // Japanese milliseconds
+        { pattern: "\u6642\u9593", suffix: "h" }
+        // Japanese hours
+      ];
+      for (const unit of cjkMultiUnits) {
+        if (remaining.startsWith(unit.pattern)) {
+          return {
+            value: numValue + unit.suffix,
+            length: length + unit.pattern.length,
+            metadata: { hasTimeUnit: true }
+          };
+        }
+      }
+      if (remaining.startsWith("ms")) {
+        return {
+          value: numValue + "ms",
+          length: length + 2,
+          metadata: { hasTimeUnit: true }
+        };
+      }
+      const cjkSingleUnits = [
+        { pattern: "\u79D2", suffix: "s" },
+        // CJK seconds
+        { pattern: "\u5206", suffix: "m" }
+        // CJK minutes
+      ];
+      for (const unit of cjkSingleUnits) {
+        if (remaining.startsWith(unit.pattern)) {
+          return {
+            value: numValue + unit.suffix,
+            length: length + 1,
+            metadata: { hasTimeUnit: true }
+          };
+        }
+      }
+      if (/^[smh](?![a-zA-Z])/.test(remaining)) {
+        return {
+          value: numValue + remaining[0],
+          length: length + 1,
+          metadata: { hasTimeUnit: true }
+        };
+      }
+    }
+    return { value: numValue, length };
+  }
+};
+var IdentifierExtractor = class {
+  constructor() {
+    this.name = "identifier";
+  }
+  canExtract(input, position) {
+    return /[a-zA-Z_]/.test(input[position]);
+  }
+  extract(input, position) {
+    let length = 0;
+    while (position + length < input.length) {
+      const char = input[position + length];
+      if (/[a-zA-Z0-9_]/.test(char)) {
+        length++;
+      } else {
+        break;
+      }
+    }
+    return length > 0 ? {
+      value: input.substring(position, position + length),
+      length
+    } : null;
+  }
+};
+var UnicodeIdentifierExtractor = class {
+  constructor() {
+    this.name = "unicode-identifier";
+  }
+  canExtract(input, position) {
+    const code = input.charCodeAt(position);
+    if (code < 128) return false;
+    return /\p{L}/u.test(input[position]);
+  }
+  extract(input, position) {
+    let length = 0;
+    while (position + length < input.length) {
+      const char = input[position + length];
+      if (/[\p{L}\p{N}\p{M}]/u.test(char)) {
+        length++;
+      } else {
+        break;
+      }
+    }
+    return length > 0 ? { value: input.substring(position, position + length), length } : null;
+  }
+};
+var WhitespaceExtractor = class {
+  constructor() {
+    this.name = "whitespace";
+  }
+  canExtract(input, position) {
+    return /\s/.test(input[position]);
+  }
+  extract(input, position) {
+    let length = 0;
+    while (position + length < input.length && /\s/.test(input[position + length])) {
+      length++;
+    }
+    return length > 0 ? {
+      value: input.substring(position, position + length),
+      length
+    } : null;
+  }
+};
+function isContextAwareExtractor(extractor) {
+  return "setContext" in extractor && typeof extractor.setContext === "function";
+}
+function createTokenizerContext(tokenizer) {
+  const ctx = {
+    language: tokenizer.language,
+    direction: tokenizer.direction,
+    lookupKeyword: tokenizer.lookupKeyword.bind(tokenizer),
+    isKeyword: tokenizer.isKeyword.bind(tokenizer),
+    isKeywordStart: tokenizer.isKeywordStart.bind(tokenizer)
+  };
+  if (tokenizer.normalizer) {
+    return { ...ctx, normalizer: tokenizer.normalizer };
+  }
+  return ctx;
+}
+
+// src/api/create-dsl.ts
+var DSLRegistry = class {
+  constructor(config) {
+    this.patterns = /* @__PURE__ */ new Map();
+    this.tokenizers = /* @__PURE__ */ new Map();
+    this.schemas = config.schemas;
+    for (const lang of config.languages) {
+      this.registerLanguage(lang);
+    }
+  }
+  registerLanguage(lang) {
+    this.tokenizers.set(lang.code, lang.tokenizer);
+    const patterns = [];
+    for (const schema of this.schemas) {
+      const pattern = generatePattern(schema, lang.patternProfile);
+      patterns.push(pattern);
+    }
+    this.patterns.set(lang.code, patterns);
+  }
+  getPatterns(language) {
+    return this.patterns.get(language) || [];
+  }
+  getTokenizer(language) {
+    return this.tokenizers.get(language);
+  }
+  getSupportedLanguages() {
+    return Array.from(this.patterns.keys());
+  }
+};
+var MultilingualDSLImpl = class {
+  constructor(config, registry, transformer) {
+    this.registry = registry;
+    this.matcher = new PatternMatcher();
+    this.transformer = transformer;
+    if (config.codeGenerator) {
+      this.codeGenerator = config.codeGenerator;
+    }
+  }
+  parse(input, language) {
+    const result = this.parseWithConfidence(input, language);
+    return result.node;
+  }
+  parseWithConfidence(input, language) {
+    const tokenizer = this.registry.getTokenizer(language);
+    if (!tokenizer) {
+      throw new Error(`No tokenizer registered for language: ${language}`);
+    }
+    const tokens = tokenizer.tokenize(input);
+    const patterns = this.registry.getPatterns(language);
+    const profile = {
+      code: language
+    };
+    for (const pattern of patterns) {
+      const match = this.matcher.matchPattern(tokens, pattern, profile);
+      if (match) {
+        const node = {
+          kind: "command",
+          action: pattern.command,
+          roles: match.captured,
+          metadata: {
+            sourceLanguage: language,
+            sourceText: input,
+            patternId: pattern.id,
+            confidence: match.confidence
+          }
+        };
+        return { node, confidence: match.confidence };
+      }
+    }
+    throw new Error(`No pattern matched for input: ${input}`);
+  }
+  validate(input, language) {
+    try {
+      const result = this.parseWithConfidence(input, language);
+      return {
+        valid: true,
+        node: result.node
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [error instanceof Error ? error.message : String(error)]
+      };
+    }
+  }
+  translate(input, fromLanguage, toLanguage) {
+    return this.transformer.transform(input, fromLanguage, toLanguage);
+  }
+  compile(input, language) {
+    if (!this.codeGenerator) {
+      return {
+        ok: false,
+        errors: ["No code generator configured for this DSL"]
+      };
+    }
+    try {
+      const result = this.parseWithConfidence(input, language);
+      const code = this.codeGenerator.generate(result.node);
+      return {
+        ok: true,
+        code,
+        node: result.node,
+        metadata: {
+          parser: "semantic",
+          confidence: result.confidence
+        }
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        errors: [error instanceof Error ? error.message : String(error)]
+      };
+    }
+  }
+  getSupportedLanguages() {
+    return this.registry.getSupportedLanguages();
+  }
+};
+function createDefaultDictionary(config) {
+  const translations = {};
+  for (const lang of config.languages) {
+    const keywords = {};
+    for (const [canonical, keywordDef] of Object.entries(lang.patternProfile.keywords)) {
+      keywords[canonical] = keywordDef.primary;
+    }
+    translations[lang.code] = keywords;
+  }
+  return new InMemoryDictionary(translations);
+}
+function createDefaultProfileProvider(config) {
+  const profiles = {};
+  for (const lang of config.languages) {
+    if (lang.grammarProfile) {
+      profiles[lang.code] = lang.grammarProfile;
+    }
+  }
+  return new InMemoryProfileProvider(profiles);
+}
+function createMultilingualDSL(config) {
+  const dictionary = config.dictionary ?? createDefaultDictionary(config);
+  const profileProvider = config.profileProvider ?? createDefaultProfileProvider(config);
+  const transformer = new GrammarTransformer({
+    dictionary,
+    profileProvider
+  });
+  const registry = new DSLRegistry(config);
+  return new MultilingualDSLImpl(config, registry, transformer);
+}
+
+// src/api/domain-registry.ts
+var DomainRegistry = class {
+  constructor() {
+    this.descriptors = /* @__PURE__ */ new Map();
+    this.dslCache = /* @__PURE__ */ new Map();
+    this.rendererCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a domain.
+   * @throws if a domain with the same name is already registered
+   */
+  register(descriptor) {
+    if (this.descriptors.has(descriptor.name)) {
+      throw new Error(`Domain already registered: ${descriptor.name}`);
+    }
+    this.descriptors.set(descriptor.name, descriptor);
+  }
+  /**
+   * Get all registered domain names.
+   */
+  getDomainNames() {
+    return Array.from(this.descriptors.keys());
+  }
+  /**
+   * Get a specific domain descriptor.
+   */
+  getDescriptor(name) {
+    return this.descriptors.get(name);
+  }
+  /**
+   * Generate MCP tool definitions for all registered domains.
+   */
+  getToolDefinitions() {
+    const tools = [];
+    for (const desc of this.descriptors.values()) {
+      tools.push(...generateToolDefinitions(desc));
+    }
+    return tools;
+  }
+  /**
+   * Check if a tool name belongs to a registered domain.
+   */
+  canHandle(toolName) {
+    const parsed = parseToolName(toolName);
+    if (!parsed) return false;
+    return this.descriptors.has(parsed.domain);
+  }
+  /**
+   * Handle a tool call by dispatching to the appropriate domain.
+   * Returns null if the tool name doesn't match any registered domain.
+   */
+  async handleToolCall(toolName, args) {
+    const parsed = parseToolName(toolName);
+    if (!parsed) return null;
+    const descriptor = this.descriptors.get(parsed.domain);
+    if (!descriptor) return null;
+    try {
+      const dsl = await this.getDSL(descriptor);
+      switch (parsed.operation) {
+        case "parse":
+          return await this.handleParse(descriptor, dsl, args);
+        case "compile":
+          return await this.handleCompile(descriptor, dsl, args);
+        case "validate":
+          return await this.handleValidate(descriptor, dsl, args);
+        case "translate":
+          return await this.handleTranslate(descriptor, dsl, args);
+        default:
+          return jsonResponse({ error: `Unknown operation: ${parsed.operation}` }, true);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return jsonResponse({ error: `${descriptor.name} tool error: ${message}` }, true);
+    }
+  }
+  /**
+   * Get the DSL instance for a named domain.
+   * Returns null if the domain is not registered.
+   * The DSL is lazily created and cached.
+   */
+  async getDSLForDomain(name) {
+    const descriptor = this.descriptors.get(name);
+    if (!descriptor) return null;
+    return this.getDSL(descriptor);
+  }
+  // ---------------------------------------------------------------------------
+  // Private: DSL/renderer lifecycle
+  // ---------------------------------------------------------------------------
+  async getDSL(descriptor) {
+    const cached = this.dslCache.get(descriptor.name);
+    if (cached) return cached;
+    const dsl = await descriptor.getDSL();
+    this.dslCache.set(descriptor.name, dsl);
+    return dsl;
+  }
+  async getRenderer(descriptor) {
+    if (!descriptor.getRenderer) return null;
+    const cached = this.rendererCache.get(descriptor.name);
+    if (cached) return cached;
+    const renderer = await descriptor.getRenderer();
+    this.rendererCache.set(descriptor.name, renderer);
+    return renderer;
+  }
+  // ---------------------------------------------------------------------------
+  // Private: Tool handlers
+  // ---------------------------------------------------------------------------
+  async handleParse(descriptor, dsl, args) {
+    const input = getString(args, descriptor.inputLabel);
+    if (!input) return missingParam(descriptor.inputLabel);
+    const language = getString(args, "language", "en");
+    const node = dsl.parse(input, language);
+    const roles = {};
+    for (const [key, value] of node.roles) {
+      roles[key] = value;
+    }
+    return jsonResponse({
+      action: node.action,
+      roles,
+      language,
+      [descriptor.inputLabel]: input
+    });
+  }
+  async handleCompile(descriptor, dsl, args) {
+    const input = getString(args, descriptor.inputLabel);
+    if (!input) return missingParam(descriptor.inputLabel);
+    const language = getString(args, "language", "en");
+    const result = dsl.compile(input, language);
+    return jsonResponse({
+      ok: result.ok,
+      code: result.code,
+      errors: result.errors,
+      language,
+      input
+    });
+  }
+  async handleValidate(descriptor, dsl, args) {
+    const input = getString(args, descriptor.inputLabel);
+    if (!input) return missingParam(descriptor.inputLabel);
+    const language = getString(args, "language", "en");
+    const result = dsl.validate(input, language);
+    return jsonResponse({
+      valid: result.valid,
+      errors: result.errors,
+      language,
+      [descriptor.inputLabel]: input
+    });
+  }
+  async handleTranslate(descriptor, dsl, args) {
+    const input = getString(args, descriptor.inputLabel);
+    if (!input) return missingParam(descriptor.inputLabel);
+    const from = getString(args, "from");
+    if (!from) return missingParam("from");
+    const to = getString(args, "to");
+    if (!to) return missingParam("to");
+    const node = dsl.parse(input, from);
+    const compiled = dsl.compile(input, from);
+    let rendered = null;
+    const renderer = await this.getRenderer(descriptor);
+    if (renderer) {
+      try {
+        rendered = typeof renderer === "function" ? renderer(node, to) : renderer.render(node, to);
+      } catch {
+      }
+    }
+    const roles = {};
+    for (const [key, value] of node.roles) {
+      roles[key] = value;
+    }
+    return jsonResponse({
+      input: { [descriptor.inputLabel]: input, language: from },
+      ...rendered != null && { rendered: { text: rendered, language: to } },
+      semantic: { action: node.action, roles },
+      ...compiled.ok && compiled.code != null && { compiled: compiled.code }
+    });
+  }
+};
+function generateToolDefinitions(desc) {
+  const tools = [];
+  const ops = desc.tools ?? ["parse", "compile", "validate", "translate"];
+  const langList = desc.languages.join(", ");
+  for (const op of ops) {
+    switch (op) {
+      case "parse":
+        tools.push({
+          name: `parse_${desc.name}`,
+          description: `Parse a ${desc.description} input into a semantic representation. Supports: ${langList}.`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              [desc.inputLabel]: {
+                type: "string",
+                description: desc.inputDescription
+              },
+              language: {
+                type: "string",
+                description: `Language code: ${langList}`,
+                default: "en"
+              }
+            },
+            required: [desc.inputLabel]
+          }
+        });
+        break;
+      case "compile":
+        tools.push({
+          name: `compile_${desc.name}`,
+          description: `Compile a ${desc.description} input to target code. Supports: ${langList}.`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              [desc.inputLabel]: {
+                type: "string",
+                description: desc.inputDescription
+              },
+              language: {
+                type: "string",
+                description: `Language code: ${langList}`,
+                default: "en"
+              }
+            },
+            required: [desc.inputLabel]
+          }
+        });
+        break;
+      case "validate":
+        tools.push({
+          name: `validate_${desc.name}`,
+          description: `Validate ${desc.description} syntax. Returns whether it parses successfully and any errors. Supports: ${langList}.`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              [desc.inputLabel]: {
+                type: "string",
+                description: `${desc.inputDescription} to validate`
+              },
+              language: {
+                type: "string",
+                description: `Language code: ${langList}`,
+                default: "en"
+              }
+            },
+            required: [desc.inputLabel]
+          }
+        });
+        break;
+      case "translate":
+        tools.push({
+          name: `translate_${desc.name}`,
+          description: `Translate ${desc.description} input between natural languages. Parses in source language and renders in target language.`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              [desc.inputLabel]: {
+                type: "string",
+                description: `${desc.inputDescription} to translate`
+              },
+              from: {
+                type: "string",
+                description: `Source language code: ${langList}`
+              },
+              to: {
+                type: "string",
+                description: `Target language code: ${langList}`
+              }
+            },
+            required: [desc.inputLabel, "from", "to"]
+          }
+        });
+        break;
+    }
+  }
+  return tools;
+}
+function parseToolName(name) {
+  const match = name.match(/^(parse|compile|validate|translate)_(.+)$/);
+  if (!match) return null;
+  return { operation: match[1], domain: match[2] };
+}
+function getString(args, name, defaultValue = "") {
+  const value = args[name];
+  return typeof value === "string" ? value : defaultValue;
+}
+function jsonResponse(data, isError) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    ...isError && { isError: true }
+  };
+}
+function missingParam(param) {
+  return jsonResponse({ error: `Missing required parameter: ${param}` }, true);
+}
+
+// src/api/dispatcher.ts
+var COMMENT_PATTERN = /^\s*(\/\/|--|#)/;
+function isSkippableLine(line) {
+  const trimmed = line.trim();
+  return trimmed === "" || COMMENT_PATTERN.test(trimmed);
+}
+var CrossDomainDispatcher = class {
+  constructor(registry, options) {
+    this.registry = registry;
+    this.minConfidence = options?.minConfidence ?? 0.5;
+    this.priority = options?.priority ?? [];
+  }
+  /**
+   * Auto-detect which domain handles the input.
+   * Tries all registered domains and returns the highest-confidence match.
+   * Returns null if no domain matches above minConfidence.
+   */
+  async detect(input, language = "en") {
+    const domainNames = this.registry.getDomainNames();
+    if (domainNames.length === 0) return null;
+    const candidates = [];
+    for (const name of domainNames) {
+      const dsl = await this.registry.getDSLForDomain(name);
+      if (!dsl) continue;
+      try {
+        const { node, confidence } = dsl.parseWithConfidence(input, language);
+        if (confidence >= this.minConfidence) {
+          candidates.push({ domain: name, node, confidence, dsl });
+        }
+      } catch {
+      }
+    }
+    if (candidates.length === 0) return null;
+    candidates.sort((a, b) => {
+      if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+      return this.getPriorityIndex(a.domain) - this.getPriorityIndex(b.domain);
+    });
+    return candidates[0];
+  }
+  /**
+   * Parse multi-line input where each line may belong to a different domain.
+   * Empty lines and comment lines (starting with //, --, or #) are skipped.
+   */
+  async parseComposite(input, language = "en") {
+    const lines = input.split("\n");
+    const statements = [];
+    const errors = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (isSkippableLine(line)) continue;
+      const trimmed = line.trim();
+      const result = await this.detect(trimmed, language);
+      if (result) {
+        statements.push({
+          line: i + 1,
+          input: trimmed,
+          domain: result.domain,
+          node: result.node,
+          confidence: result.confidence
+        });
+      } else {
+        errors.push({
+          line: i + 1,
+          input: trimmed,
+          message: "No domain matched this input"
+        });
+      }
+    }
+    return { statements, errors };
+  }
+  /**
+   * Compile input using auto-detected domain.
+   * Returns the compilation result with the domain name.
+   */
+  async compile(input, language = "en") {
+    const detected = await this.detect(input, language);
+    if (!detected) return null;
+    const result = detected.dsl.compile(input, language);
+    return { ...result, domain: detected.domain };
+  }
+  /**
+   * Validate input against all domains, returning the best match.
+   */
+  async validate(input, language = "en") {
+    const detected = await this.detect(input, language);
+    if (!detected) {
+      return { valid: false, errors: ["No domain matched this input"] };
+    }
+    const result = detected.dsl.validate(input, language);
+    return { ...result, domain: detected.domain };
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  getPriorityIndex(domain) {
+    const idx = this.priority.indexOf(domain);
+    return idx === -1 ? this.priority.length : idx;
+  }
+};
+
+// src/aot/domain-scanner.ts
+function buildAttributePatterns(attributes) {
+  const patterns = [];
+  for (const attr of attributes) {
+    const escaped = attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    patterns.push(new RegExp(`${escaped}\\s*=\\s*"([^"]+)"`, "g"));
+    patterns.push(new RegExp(`${escaped}\\s*=\\s*'([^']+)'`, "g"));
+    patterns.push(new RegExp(`${escaped}\\s*=\\s*\`([^\`]+)\``, "g"));
+  }
+  return patterns;
+}
+function buildScriptPatterns(scriptTypes) {
+  return scriptTypes.map((type) => {
+    const escaped = type.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`<script[^>]*type=["']?${escaped}["']?[^>]*>([\\s\\S]*?)<\\/script>`, "gi");
+  });
+}
+function getLineNumber(source, position) {
+  let line = 1;
+  for (let i = 0; i < position && i < source.length; i++) {
+    if (source[i] === "\n") line++;
+  }
+  return line;
+}
+function extractElementId(source, matchIndex) {
+  const before = source.lastIndexOf("<", matchIndex);
+  if (before === -1) return void 0;
+  const tagChunk = source.slice(before, matchIndex + 200);
+  const idMatch = tagChunk.match(/\bid=["']([^"']+)["']/);
+  return idMatch?.[1];
+}
+function extractLangAttribute(source, matchIndex) {
+  const before = source.lastIndexOf("<", matchIndex);
+  if (before === -1) return void 0;
+  const tagChunk = source.slice(before, matchIndex + 200);
+  const langMatch = tagChunk.match(/\blang=["']([^"']+)["']/);
+  return langMatch?.[1];
+}
+var DomainAwareScanner = class {
+  constructor(configs) {
+    this.configs = configs;
+  }
+  /**
+   * Extract all domain snippets from an HTML source string.
+   */
+  extract(source, filename) {
+    const snippets = [];
+    for (const config of this.configs) {
+      const defaultLang = config.defaultLanguage ?? "en";
+      const attrPatterns = buildAttributePatterns(config.attributes);
+      for (const pattern of attrPatterns) {
+        pattern.lastIndex = 0;
+        let match;
+        while (match = pattern.exec(source)) {
+          const code = match[1].trim();
+          if (!code) continue;
+          const line = getLineNumber(source, match.index);
+          const elementId = extractElementId(source, match.index);
+          const langAttr = extractLangAttribute(source, match.index);
+          snippets.push({
+            domain: config.domain,
+            code,
+            language: langAttr ?? defaultLang,
+            file: filename,
+            line,
+            column: 1,
+            ...elementId != null && { elementId }
+          });
+        }
+      }
+      if (config.scriptTypes) {
+        const scriptPatterns = buildScriptPatterns(config.scriptTypes);
+        for (const pattern of scriptPatterns) {
+          pattern.lastIndex = 0;
+          let match;
+          while (match = pattern.exec(source)) {
+            const code = match[1].trim();
+            if (!code) continue;
+            const line = getLineNumber(source, match.index);
+            snippets.push({
+              domain: config.domain,
+              code,
+              language: defaultLang,
+              file: filename,
+              line,
+              column: 1
+            });
+          }
+        }
+      }
+    }
+    return snippets;
+  }
+  /**
+   * Extract snippets from multiple files.
+   */
+  async extractFromFiles(files, readFile) {
+    const allSnippets = [];
+    for (const file of files) {
+      try {
+        const source = await readFile(file);
+        const snippets = this.extract(source, file);
+        allSnippets.push(...snippets);
+      } catch {
+      }
+    }
+    return allSnippets;
+  }
+};
+
+// src/aot/aot-orchestrator.ts
+var AOTOrchestrator = class {
+  constructor(options) {
+    this.backends = /* @__PURE__ */ new Map();
+    this.options = {
+      confidenceThreshold: options?.confidenceThreshold ?? 0.7,
+      continueOnError: options?.continueOnError ?? true,
+      debug: options?.debug ?? false
+    };
+  }
+  /**
+   * Register a domain compilation backend.
+   * @throws if a backend with the same domain name is already registered
+   */
+  registerBackend(backend) {
+    if (this.backends.has(backend.domain)) {
+      throw new Error(`Backend already registered for domain: ${backend.domain}`);
+    }
+    this.backends.set(backend.domain, backend);
+  }
+  /**
+   * Scan source files and compile all domain snippets.
+   */
+  async compileFiles(files, readFile) {
+    const configs = Array.from(this.backends.values()).map((b) => b.scanConfig);
+    const scanner = new DomainAwareScanner(configs);
+    const snippets = await scanner.extractFromFiles(files, readFile);
+    if (this.options.debug) {
+      console.log(`[aot] Extracted ${snippets.length} snippets from ${files.length} files`);
+    }
+    const compiled = [];
+    const errors = [];
+    const domainBreakdown = {};
+    for (const snippet of snippets) {
+      domainBreakdown[snippet.domain] = (domainBreakdown[snippet.domain] ?? 0) + 1;
+      const result = this.compileSnippet(snippet);
+      if ("error" in result) {
+        errors.push({
+          domain: snippet.domain,
+          source: snippet.code,
+          file: snippet.file,
+          line: snippet.line,
+          message: result.error
+        });
+        if (!this.options.continueOnError) break;
+      } else {
+        compiled.push(result);
+      }
+    }
+    return {
+      compiled,
+      errors,
+      stats: {
+        totalSnippets: snippets.length,
+        compiledCount: compiled.length,
+        errorCount: errors.length,
+        domainBreakdown
+      }
+    };
+  }
+  /**
+   * Compile a single extracted snippet.
+   * Returns the compiled result or an error object.
+   */
+  compileSnippet(snippet) {
+    const backend = this.backends.get(snippet.domain);
+    if (!backend) {
+      return { error: `No backend registered for domain: ${snippet.domain}` };
+    }
+    try {
+      const result = backend.dsl.compile(snippet.code, snippet.language);
+      if (!result.ok || !result.code) {
+        return { error: result.errors?.join("; ") ?? "Compilation failed" };
+      }
+      return {
+        domain: snippet.domain,
+        source: snippet.code,
+        compiled: result.code,
+        language: snippet.language,
+        file: snippet.file,
+        line: snippet.line
+      };
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  /**
+   * Generate combined output from compilation results.
+   */
+  generateOutput(result, options) {
+    const format = options?.format ?? "esm";
+    const includeComments = options?.includeComments ?? true;
+    const groupByDomain = options?.groupByDomain ?? true;
+    const sections = [];
+    if (includeComments) {
+      sections.push(`// Generated by @lokascript/framework AOT compiler`);
+      sections.push(
+        `// ${result.stats.compiledCount} snippets compiled, ${result.stats.errorCount} errors`
+      );
+      sections.push("");
+    }
+    if (groupByDomain) {
+      const grouped = /* @__PURE__ */ new Map();
+      for (const snippet of result.compiled) {
+        const list = grouped.get(snippet.domain) ?? [];
+        list.push(snippet);
+        grouped.set(snippet.domain, list);
+      }
+      for (const [domain, snippets] of grouped) {
+        if (includeComments) {
+          sections.push(`// === Domain: ${domain} ===`);
+          sections.push("");
+        }
+        for (const snippet of snippets) {
+          if (includeComments) {
+            sections.push(`// Source: ${snippet.file}:${snippet.line}`);
+            sections.push(`// Language: ${snippet.language}`);
+          }
+          sections.push(snippet.compiled);
+          sections.push("");
+        }
+      }
+    } else {
+      for (const snippet of result.compiled) {
+        if (includeComments) {
+          sections.push(`// [${snippet.domain}] ${snippet.file}:${snippet.line}`);
+        }
+        sections.push(snippet.compiled);
+        sections.push("");
+      }
+    }
+    const body = sections.join("\n").trimEnd();
+    switch (format) {
+      case "cjs":
+        return `'use strict';
+
+${body}
+`;
+      case "iife":
+        return `(function() {
+${body}
+})();
+`;
+      case "esm":
+      default:
+        return `${body}
+`;
+    }
+  }
+};
+
+// src/schema/command-schema.ts
+function defineCommand(schema) {
+  return {
+    description: schema.description || `${schema.action} command`,
+    category: schema.category || "general",
+    primaryRole: schema.primaryRole || schema.roles[0]?.role || "patient",
+    ...schema,
+    action: schema.action,
+    roles: schema.roles
+  };
+}
+function defineRole(role) {
+  return {
+    description: role.description || `${role.role} role`,
+    ...role,
+    role: role.role,
+    required: role.required,
+    expectedTypes: role.expectedTypes
+  };
+}
+
+// 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 { keywords, markers } = buildTablesFromProfiles(schemas, profiles);
+  const { sovLanguages } = detectWordOrders(profiles);
+  const schemaMap = /* @__PURE__ */ new Map();
+  for (const s of schemas) schemaMap.set(s.action, s);
+  return {
+    render(node, language) {
+      const schema = schemaMap.get(node.action);
+      if (!schema) return node.action;
+      const keyword = lookupKeyword(keywords, node.action, language);
+      const isSOV = sovLanguages.has(language);
+      const roleParts = [];
+      for (const role of schema.roles) {
+        const value = extractRoleValue(node, role.role);
+        if (!value && !role.required) continue;
+        const markerText = role.markerOverride?.[language] ?? markers[role.role]?.[language] ?? void 0;
+        roleParts.push({
+          ...markerText != null && { marker: markerText },
+          value: value || "",
+          role
+        });
+      }
+      const parts = [];
+      if (isSOV) {
+        for (const rp of roleParts) {
+          if (rp.value) parts.push(rp.value);
+          if (rp.marker) parts.push(rp.marker);
+        }
+        parts.push(keyword);
+      } else {
+        parts.push(keyword);
+        for (const rp of roleParts) {
+          if (rp.marker) parts.push(rp.marker);
+          if (rp.value) parts.push(rp.value);
+        }
+      }
+      return buildPhrase(...parts);
+    }
+  };
+}
+
+// src/generation/diagnostics.ts
+function createDiagnosticCollector() {
+  const diagnostics = [];
+  function addWithSeverity(severity, message, options) {
+    const diag = {
+      message,
+      severity,
+      ...options?.code != null && { code: options.code },
+      ...options?.line != null && { line: options.line },
+      ...options?.column != null && { column: options.column },
+      ...options?.source != null && { source: options.source },
+      ...options?.suggestions != null && options.suggestions.length > 0 && { suggestions: options.suggestions }
+    };
+    diagnostics.push(diag);
+  }
+  return {
+    error(message, options) {
+      addWithSeverity("error", message, options);
+    },
+    warning(message, options) {
+      addWithSeverity("warning", message, options);
+    },
+    info(message, options) {
+      addWithSeverity("info", message, options);
+    },
+    add(diagnostic) {
+      diagnostics.push(diagnostic);
+    },
+    hasErrors() {
+      return diagnostics.some((d) => d.severity === "error");
+    },
+    getDiagnostics() {
+      return diagnostics;
+    },
+    toResult() {
+      let errors = 0;
+      let warnings = 0;
+      let infos = 0;
+      for (const d of diagnostics) {
+        if (d.severity === "error") errors++;
+        else if (d.severity === "warning") warnings++;
+        else infos++;
+      }
+      return {
+        ok: errors === 0,
+        diagnostics,
+        summary: { errors, warnings, infos }
+      };
+    }
+  };
+}
+function fromError(error, options) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    message,
+    severity: "error",
+    ...options?.code != null && { code: options.code },
+    ...options?.line != null && { line: options.line },
+    ...options?.column != null && { column: options.column },
+    ...options?.source != null && { source: options.source },
+    ...options?.suggestions != null && options.suggestions.length > 0 && { suggestions: options.suggestions }
+  };
+}
+function filterBySeverity(diagnostics, severity) {
+  return diagnostics.filter((d) => d.severity === severity);
+}
+
+// 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 isAsciiLetter(char) {
+  return /[a-zA-Z]/.test(char);
+}
+function isAsciiIdentifierChar(char) {
+  return /[a-zA-Z0-9_-]/.test(char);
+}
+
+// src/core/tokenization/extractors.ts
+function extractCssSelector(input, startPos) {
+  if (startPos >= input.length) return null;
+  const char = input[startPos];
+  if (!isSelectorStart(char)) return null;
+  let pos = startPos;
+  let selector = "";
+  if (char === "#" || char === ".") {
+    selector += input[pos++];
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    if (selector.length <= 1) return null;
+    if (pos < input.length && input[pos] === "." && char === "#") {
+      const methodStart = pos + 1;
+      let methodEnd = methodStart;
+      while (methodEnd < input.length && isAsciiIdentifierChar(input[methodEnd])) {
+        methodEnd++;
+      }
+      if (methodEnd < input.length && input[methodEnd] === "(") {
+        return selector;
+      }
+    }
+  } else if (char === "[") {
+    let depth = 1;
+    let inQuote = false;
+    let quoteChar = null;
+    let escaped = false;
+    selector += input[pos++];
+    while (pos < input.length && depth > 0) {
+      const c = input[pos];
+      selector += c;
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (inQuote) {
+        if (c === quoteChar) {
+          inQuote = false;
+          quoteChar = null;
+        }
+      } else {
+        if (c === '"' || c === "'" || c === "`") {
+          inQuote = true;
+          quoteChar = c;
+        } else if (c === "[") {
+          depth++;
+        } else if (c === "]") {
+          depth--;
+        }
+      }
+      pos++;
+    }
+    if (depth !== 0) return null;
+  } else if (char === "@") {
+    selector += input[pos++];
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    if (selector.length <= 1) return null;
+  } else if (char === "*") {
+    selector += input[pos++];
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    if (selector.length <= 1) return null;
+  } else if (char === "<") {
+    selector += input[pos++];
+    if (pos >= input.length || !isAsciiLetter(input[pos])) return null;
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    while (pos < input.length) {
+      const modChar = input[pos];
+      if (modChar === ".") {
+        selector += input[pos++];
+        if (pos >= input.length || !isAsciiIdentifierChar(input[pos])) {
+          return null;
+        }
+        while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+          selector += input[pos++];
+        }
+      } else if (modChar === "#") {
+        selector += input[pos++];
+        if (pos >= input.length || !isAsciiIdentifierChar(input[pos])) {
+          return null;
+        }
+        while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+          selector += input[pos++];
+        }
+      } else if (modChar === "[") {
+        let depth = 1;
+        let inQuote = false;
+        let quoteChar = null;
+        let escaped = false;
+        selector += input[pos++];
+        while (pos < input.length && depth > 0) {
+          const c = input[pos];
+          selector += c;
+          if (escaped) {
+            escaped = false;
+          } else if (c === "\\") {
+            escaped = true;
+          } else if (inQuote) {
+            if (c === quoteChar) {
+              inQuote = false;
+              quoteChar = null;
+            }
+          } else {
+            if (c === '"' || c === "'" || c === "`") {
+              inQuote = true;
+              quoteChar = c;
+            } else if (c === "[") {
+              depth++;
+            } else if (c === "]") {
+              depth--;
+            }
+          }
+          pos++;
+        }
+        if (depth !== 0) return null;
+      } else {
+        break;
+      }
+    }
+    while (pos < input.length && isWhitespace(input[pos])) {
+      selector += input[pos++];
+    }
+    if (pos < input.length && input[pos] === "/") {
+      selector += input[pos++];
+      while (pos < input.length && isWhitespace(input[pos])) {
+        selector += input[pos++];
+      }
+    }
+    if (pos >= input.length || input[pos] !== ">") return null;
+    selector += input[pos++];
+  }
+  return selector || null;
+}
+function isPossessiveMarker(input, pos) {
+  if (pos >= input.length || input[pos] !== "'") return false;
+  if (pos + 1 >= input.length) return false;
+  const nextChar = input[pos + 1].toLowerCase();
+  if (nextChar !== "s") return false;
+  if (pos + 2 >= input.length) return true;
+  const afterS = input[pos + 2];
+  return isWhitespace(afterS) || afterS === "*" || !isAsciiIdentifierChar(afterS);
+}
+function extractStringLiteral(input, startPos) {
+  if (startPos >= input.length) return null;
+  const openQuote = input[startPos];
+  if (!isQuote(openQuote)) return null;
+  if (openQuote === "'" && isPossessiveMarker(input, startPos)) {
+    return null;
+  }
+  const closeQuoteMap = {
+    '"': '"',
+    "'": "'",
+    "`": "`",
+    "\u300C": "\u300D"
+  };
+  const closeQuote = closeQuoteMap[openQuote];
+  if (!closeQuote) return null;
+  let pos = startPos + 1;
+  let literal = openQuote;
+  let escaped = false;
+  while (pos < input.length) {
+    const char = input[pos];
+    literal += char;
+    if (escaped) {
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === closeQuote) {
+      return literal;
+    }
+    pos++;
+  }
+  return literal;
+}
+function isUrlStart(input, pos) {
+  if (pos >= input.length) return false;
+  const char = input[pos];
+  const next = input[pos + 1] || "";
+  const third = input[pos + 2] || "";
+  if (char === "/" && next !== "/" && /[a-zA-Z0-9._-]/.test(next)) {
+    return true;
+  }
+  if (char === "/" && next === "/" && /[a-zA-Z]/.test(third)) {
+    return true;
+  }
+  if (char === "." && (next === "/" || next === "." && third === "/")) {
+    return true;
+  }
+  const slice = input.slice(pos, pos + 8).toLowerCase();
+  if (slice.startsWith("http://") || slice.startsWith("https://")) {
+    return true;
+  }
+  return false;
+}
+function extractUrl(input, startPos) {
+  if (!isUrlStart(input, startPos)) return null;
+  let pos = startPos;
+  let url = "";
+  const urlChars = /[a-zA-Z0-9/:._\-?&=%@+~!$'()*,;[\]]/;
+  while (pos < input.length) {
+    const char = input[pos];
+    if (char === "#") {
+      if (url.length > 0 && /[a-zA-Z0-9/.]$/.test(url)) {
+        url += char;
+        pos++;
+        while (pos < input.length && /[a-zA-Z0-9_-]/.test(input[pos])) {
+          url += input[pos++];
+        }
+      }
+      break;
+    }
+    if (urlChars.test(char)) {
+      url += char;
+      pos++;
+    } else {
+      break;
+    }
+  }
+  if (url.length < 2) return null;
+  return url;
+}
+function extractNumber(input, startPos) {
+  if (startPos >= input.length) return null;
+  const char = input[startPos];
+  if (!isDigit(char) && char !== "-" && char !== "+") return null;
+  let pos = startPos;
+  let number = "";
+  if (input[pos] === "-" || input[pos] === "+") {
+    number += input[pos++];
+  }
+  if (pos >= input.length || !isDigit(input[pos])) {
+    return null;
+  }
+  while (pos < input.length && isDigit(input[pos])) {
+    number += input[pos++];
+  }
+  if (pos < input.length && input[pos] === ".") {
+    number += input[pos++];
+    while (pos < input.length && isDigit(input[pos])) {
+      number += input[pos++];
+    }
+  }
+  if (pos < input.length) {
+    const suffix = input.slice(pos, pos + 2);
+    if (suffix === "ms") {
+      number += "ms";
+    } else if (input[pos] === "s" || input[pos] === "m" || input[pos] === "h") {
+      number += input[pos];
+    }
+  }
+  return number;
+}
+
+// src/core/tokenization/extractors/operator.ts
+var DEFAULT_OPERATORS = [
+  // Three-character operators
+  "===",
+  "!==",
+  "->",
+  // Two-character operators
+  "==",
+  "!=",
+  "<=",
+  ">=",
+  "&&",
+  "||",
+  "**",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  // Single-character operators
+  "+",
+  "-",
+  "*",
+  "/",
+  "=",
+  ">",
+  "<",
+  "!",
+  "&",
+  "|",
+  "%",
+  "^",
+  "~"
+];
+var OperatorExtractor = class {
+  constructor(operators = DEFAULT_OPERATORS) {
+    this.operators = operators;
+    this.name = "operator";
+    this.operators = [...operators].sort((a, b) => b.length - a.length);
+  }
+  canExtract(input, position) {
+    return this.operators.some((op) => input.startsWith(op, position));
+  }
+  extract(input, position) {
+    for (const op of this.operators) {
+      if (input.startsWith(op, position)) {
+        return {
+          value: op,
+          length: op.length
+        };
+      }
+    }
+    return null;
+  }
+};
+
+// src/core/tokenization/extractors/punctuation.ts
+var DEFAULT_PUNCTUATION = "()[]{},:;";
+var PunctuationExtractor = class {
+  constructor(punctuation = DEFAULT_PUNCTUATION) {
+    this.punctuation = punctuation;
+    this.name = "punctuation";
+  }
+  canExtract(input, position) {
+    return this.punctuation.includes(input[position]);
+  }
+  extract(input, position) {
+    const char = input[position];
+    if (this.punctuation.includes(char)) {
+      return {
+        value: char,
+        length: 1
+      };
+    }
+    return null;
+  }
+};
+
+// src/core/tokenization/default-extractors.ts
+function getDefaultExtractors() {
+  return [
+    new StringLiteralExtractor(),
+    // "strings", 'strings', `strings`
+    new NumberExtractor(),
+    // 123, 45.67
+    new OperatorExtractor(),
+    // +, -, *, /, =, >, <, etc.
+    new PunctuationExtractor(),
+    // ( ) [ ] { } , : ;
+    new IdentifierExtractor(),
+    // variable_names, functionNames (ASCII)
+    new UnicodeIdentifierExtractor()
+    // CJK, Arabic, Cyrillic, etc.
+  ];
+}
+function withDefaultExtractors(tokenizer) {
+  tokenizer.registerExtractors(getDefaultExtractors());
+  return tokenizer;
+}
+
+// src/core/tokenization/char-classifiers.ts
+function createUnicodeRangeClassifier(ranges) {
+  return (char) => {
+    const code = char.charCodeAt(0);
+    return ranges.some(([start, end]) => code >= start && code <= end);
+  };
+}
+function combineClassifiers(...classifiers) {
+  return (char) => classifiers.some((fn) => fn(char));
+}
+function createLatinCharClassifiers(letterPattern) {
+  const isLetter = (char) => letterPattern.test(char);
+  const isIdentifierChar = (char) => isLetter(char) || /[0-9_-]/.test(char);
+  return { isLetter, isIdentifierChar };
+}
+
+// src/core/tokenization/base-tokenizer.ts
+var SIMPLE_TOKENIZER_OPERATOR_SET = new Set(DEFAULT_OPERATORS);
+var _BaseTokenizer = class _BaseTokenizer {
+  constructor() {
+    /** Keywords derived from profile, sorted longest-first for greedy matching */
+    this.profileKeywords = [];
+    /** Map for O(1) keyword lookups by lowercase native word */
+    this.profileKeywordMap = /* @__PURE__ */ new Map();
+    /**
+     * Pluggable value extractors for domain-specific syntax.
+     * When registered, BaseTokenizer will use extractor-based tokenization instead of legacy methods.
+     */
+    this.extractors = [];
+  }
+  /**
+   * Tokenize input string to token stream.
+   * Delegates to extractor-based tokenization if extractors are registered,
+   * otherwise subclass must override this method.
+   *
+   * @param input - Input string to tokenize
+   * @returns Token stream
+   */
+  tokenize(input) {
+    if (this.isUsingExtractors()) {
+      return this.tokenizeWithExtractors(input);
+    }
+    throw new Error(
+      `${this.constructor.name}: tokenize() not implemented and no extractors registered. Either register extractors or override tokenize() method.`
+    );
+  }
+  /**
+   * Register a value extractor for domain-specific syntax.
+   * Extractors are tried in registration order during tokenization.
+   * Context-aware extractors automatically receive the tokenizer context.
+   *
+   * @param extractor - Value extractor to register
+   */
+  registerExtractor(extractor) {
+    if (isContextAwareExtractor(extractor)) {
+      extractor.setContext(createTokenizerContext(this));
+    }
+    this.extractors.push(extractor);
+  }
+  /**
+   * Register multiple value extractors at once.
+   *
+   * @param extractors - Array of value extractors to register
+   */
+  registerExtractors(extractors) {
+    for (const extractor of extractors) {
+      this.registerExtractor(extractor);
+    }
+  }
+  /**
+   * Clear all registered extractors.
+   * Returns tokenizer to legacy mode.
+   */
+  clearExtractors() {
+    this.extractors = [];
+  }
+  /**
+   * Check if this tokenizer is using extractor-based tokenization.
+   * Returns true if any extractors are registered.
+   */
+  isUsingExtractors() {
+    return this.extractors.length > 0;
+  }
+  /**
+   * Tokenize input using registered value extractors.
+   * This is the new path - extractors handle all syntax detection.
+   *
+   * @param input - Input string to tokenize
+   * @returns Token stream
+   */
+  tokenizeWithExtractors(input) {
+    const tokens = [];
+    let pos = 0;
+    while (pos < input.length) {
+      while (pos < input.length && isWhitespace(input[pos])) {
+        pos++;
+      }
+      if (pos >= input.length) break;
+      let extracted = false;
+      for (const extractor of this.extractors) {
+        if (extractor.canExtract(input, pos)) {
+          const result = extractor.extract(input, pos);
+          if (result) {
+            const normalized2 = result.metadata?.normalized;
+            const stem = result.metadata?.stem;
+            const stemConfidence = result.metadata?.stemConfidence;
+            const cleanMetadata = {};
+            if (result.metadata) {
+              for (const [key, value] of Object.entries(result.metadata)) {
+                if (key !== "normalized" && key !== "stem" && key !== "stemConfidence") {
+                  cleanMetadata[key] = value;
+                }
+              }
+            }
+            const options = {};
+            if (normalized2) options.normalized = normalized2;
+            if (stem) options.stem = stem;
+            if (stemConfidence !== void 0) options.stemConfidence = stemConfidence;
+            if (Object.keys(cleanMetadata).length > 0) options.metadata = cleanMetadata;
+            tokens.push(
+              createToken(
+                result.value,
+                this.classifyToken(result.value),
+                createPosition(pos, pos + result.length),
+                Object.keys(options).length > 0 ? options : void 0
+              )
+            );
+            pos += result.length;
+            extracted = true;
+            break;
+          }
+        }
+      }
+      if (!extracted) {
+        const char = input[pos];
+        const kind = this.classifyUnknownChar(char);
+        tokens.push(createToken(char, kind, createPosition(pos, pos + 1)));
+        pos++;
+      }
+    }
+    return new TokenStreamImpl(tokens, this.language);
+  }
+  /**
+   * Classify an unknown character when no extractor matches.
+   * Provides sensible defaults for common syntax.
+   *
+   * @param char - Character to classify
+   * @returns Token kind
+   */
+  classifyUnknownChar(char) {
+    if ("()[]{},:;".includes(char)) return "punctuation";
+    if ("+-*/<>=!&|".includes(char)) return "operator";
+    return "identifier";
+  }
+  /**
+   * Check if current position is a property access (obj.prop) vs CSS selector (.active).
+   * Property access: no whitespace before '.', previous token is identifier/keyword/selector.
+   * Also detects standalone method calls: .identifier( pattern.
+   *
+   * Returns true if '.' was emitted as an operator token and pos should advance by 1.
+   * Returns false if this is a CSS selector and should be handled by trySelector().
+   */
+  tryPropertyAccess(input, pos, tokens) {
+    if (input[pos] !== ".") return false;
+    const lastToken = tokens[tokens.length - 1];
+    const hasWhitespaceBefore = lastToken && lastToken.position.end < pos;
+    const isPropertyAccess = lastToken && !hasWhitespaceBefore && (lastToken.kind === "identifier" || lastToken.kind === "keyword" || lastToken.kind === "selector");
+    if (isPropertyAccess) {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    const methodStart = pos + 1;
+    let methodEnd = methodStart;
+    while (methodEnd < input.length && isAsciiIdentifierChar(input[methodEnd])) {
+      methodEnd++;
+    }
+    if (methodEnd < input.length && input[methodEnd] === "(") {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Initialize keyword mappings from a language profile.
+   * Builds a list of native→english mappings from:
+   * - profile.keywords (primary + alternatives)
+   * - profile.references (me, it, you, etc.)
+   * - profile.roleMarkers (into, from, with, etc.)
+   *
+   * Results are sorted longest-first for greedy matching (important for non-space languages).
+   * Extras take precedence over profile entries when there are duplicates.
+   *
+   * @param profile - Language profile containing keyword translations
+   * @param extras - Additional keyword entries to include (literals, positional, events)
+   */
+  initializeKeywordsFromProfile(profile, extras = []) {
+    const keywordMap = /* @__PURE__ */ new Map();
+    if (profile.keywords) {
+      for (const [normalized2, translation] of Object.entries(profile.keywords)) {
+        keywordMap.set(translation.primary, {
+          native: translation.primary,
+          normalized: translation.normalized || normalized2
+        });
+        if (translation.alternatives) {
+          for (const alt of translation.alternatives) {
+            keywordMap.set(alt, {
+              native: alt,
+              normalized: translation.normalized || normalized2
+            });
+          }
+        }
+      }
+    }
+    if (profile.references) {
+      for (const [normalized2, native] of Object.entries(profile.references)) {
+        keywordMap.set(native, { native, normalized: normalized2 });
+      }
+      for (const canonical of Object.keys(profile.references)) {
+        if (!keywordMap.has(canonical)) {
+          keywordMap.set(canonical, { native: canonical, normalized: canonical });
+        }
+      }
+    }
+    if (profile.roleMarkers) {
+      for (const [role, marker] of Object.entries(profile.roleMarkers)) {
+        if (marker.primary) {
+          keywordMap.set(marker.primary, { native: marker.primary, normalized: role });
+        }
+        if (marker.alternatives) {
+          for (const alt of marker.alternatives) {
+            keywordMap.set(alt, { native: alt, normalized: role });
+          }
+        }
+      }
+    }
+    if (profile.possessive?.keywords) {
+      for (const [native, normalized2] of Object.entries(profile.possessive.keywords)) {
+        keywordMap.set(native, { native, normalized: normalized2 });
+      }
+    }
+    for (const extra of extras) {
+      keywordMap.set(extra.native, extra);
+    }
+    this.profileKeywords = Array.from(keywordMap.values()).sort(
+      (a, b) => b.native.length - a.native.length
+    );
+    this.profileKeywordMap = /* @__PURE__ */ new Map();
+    for (const keyword of this.profileKeywords) {
+      this.profileKeywordMap.set(keyword.native.toLowerCase(), keyword);
+      const normalized2 = this.removeDiacritics(keyword.native);
+      if (normalized2 !== keyword.native && !this.profileKeywordMap.has(normalized2.toLowerCase())) {
+        this.profileKeywordMap.set(normalized2.toLowerCase(), keyword);
+      }
+    }
+  }
+  /**
+   * Remove diacritical marks from a word for normalization.
+   * Primarily for Arabic (shadda, fatha, kasra, damma, sukun, etc.)
+   * but could be extended for other languages.
+   *
+   * @param word - Word to normalize
+   * @returns Word without diacritics
+   */
+  removeDiacritics(word) {
+    return word.replace(/[\u064B-\u0652\u0670]/g, "");
+  }
+  /**
+   * Try to match a keyword from profile at the current position.
+   * Uses longest-first greedy matching (important for non-space languages).
+   *
+   * @param input - Input string
+   * @param pos - Current position
+   * @returns Token if matched, null otherwise
+   */
+  tryProfileKeyword(input, pos) {
+    for (const entry of this.profileKeywords) {
+      if (input.slice(pos).startsWith(entry.native)) {
+        return createToken(
+          entry.native,
+          "keyword",
+          createPosition(pos, pos + entry.native.length),
+          entry.normalized
+        );
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if the remaining input starts with any known keyword.
+   * Useful for non-space languages to detect word boundaries.
+   *
+   * @param input - Input string
+   * @param pos - Current position
+   * @returns true if a keyword starts at this position
+   */
+  isKeywordStart(input, pos) {
+    const remaining = input.slice(pos);
+    return this.profileKeywords.some((entry) => remaining.startsWith(entry.native));
+  }
+  /**
+   * Look up a keyword by native word (case-insensitive).
+   * O(1) lookup using the keyword map.
+   *
+   * @param native - Native word to look up
+   * @returns KeywordEntry if found, undefined otherwise
+   */
+  lookupKeyword(native) {
+    return this.profileKeywordMap.get(native.toLowerCase());
+  }
+  /**
+   * Check if a word is a known keyword (case-insensitive).
+   * O(1) lookup using the keyword map.
+   *
+   * @param native - Native word to check
+   * @returns true if the word is a keyword
+   */
+  isKeyword(native) {
+    return this.profileKeywordMap.has(native.toLowerCase());
+  }
+  /**
+   * Set the morphological normalizer for this tokenizer.
+   */
+  setNormalizer(normalizer) {
+    this.normalizer = normalizer;
+  }
+  /**
+   * Try to normalize a word using the morphological normalizer.
+   * Returns null if no normalizer is set or normalization fails.
+   *
+   * Note: We don't check isNormalizable() here because the individual tokenizers
+   * historically called normalize() directly without that check. The normalize()
+   * method itself handles returning noChange() for words that can't be normalized.
+   */
+  tryNormalize(word) {
+    if (!this.normalizer) return null;
+    const result = this.normalizer.normalize(word);
+    if (result.stem !== word && result.confidence >= 0.7) {
+      return result;
+    }
+    return null;
+  }
+  /**
+   * Try morphological normalization and keyword lookup.
+   *
+   * If the word can be normalized to a stem that matches a known keyword,
+   * returns a keyword token with morphological metadata (stem, stemConfidence).
+   *
+   * This is the common pattern for handling conjugated verbs across languages:
+   * 1. Normalize the word (e.g., "toggled" → "toggle")
+   * 2. Look up the stem in the keyword map
+   * 3. Create a token with both the original form and stem metadata
+   *
+   * @param word - The word to normalize and look up
+   * @param startPos - Start position for the token
+   * @param endPos - End position for the token
+   * @returns Token if stem matches a keyword, null otherwise
+   */
+  tryMorphKeywordMatch(word, startPos, endPos) {
+    const result = this.tryNormalize(word);
+    if (!result) return null;
+    const stemEntry = this.lookupKeyword(result.stem);
+    if (!stemEntry) return null;
+    const tokenOptions = {
+      normalized: stemEntry.normalized,
+      stem: result.stem,
+      stemConfidence: result.confidence
+    };
+    return createToken(word, "keyword", createPosition(startPos, endPos), tokenOptions);
+  }
+  /**
+   * Try to extract a CSS selector at the current position.
+   */
+  trySelector(input, pos) {
+    const selector = extractCssSelector(input, pos);
+    if (selector) {
+      return createToken(selector, "selector", createPosition(pos, pos + selector.length));
+    }
+    return null;
+  }
+  /**
+   * Try to extract an event modifier at the current position.
+   * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
+   */
+  tryEventModifier(input, pos) {
+    if (input[pos] !== ".") {
+      return null;
+    }
+    const match = input.slice(pos).match(/^\.(?:once|debounce|throttle|queue)(?:\(([^)]+)\))?(?:\s|$|\.)/);
+    if (!match) {
+      return null;
+    }
+    const fullMatch = match[0].replace(/(\s|\.)$/, "");
+    const modifierName = fullMatch.slice(1).split("(")[0];
+    const value = match[1];
+    const token = createToken(
+      fullMatch,
+      "event-modifier",
+      createPosition(pos, pos + fullMatch.length)
+    );
+    return {
+      ...token,
+      metadata: {
+        modifierName,
+        value: value ? modifierName === "queue" ? value : parseInt(value, 10) : void 0
+      }
+    };
+  }
+  /**
+   * Try to extract a string literal at the current position.
+   */
+  tryString(input, pos) {
+    const literal = extractStringLiteral(input, pos);
+    if (literal) {
+      return createToken(literal, "literal", createPosition(pos, pos + literal.length));
+    }
+    return null;
+  }
+  /**
+   * Try to extract a number at the current position.
+   */
+  tryNumber(input, pos) {
+    const number = extractNumber(input, pos);
+    if (number) {
+      return createToken(number, "literal", createPosition(pos, pos + number.length));
+    }
+    return null;
+  }
+  /**
+   * Try to match a time unit from a list of patterns.
+   *
+   * @param input - Input string
+   * @param pos - Position after the number
+   * @param timeUnits - Array of time unit mappings (native pattern → standard suffix)
+   * @param skipWhitespace - Whether to skip whitespace before time unit (default: false)
+   * @returns Object with matched suffix and new position, or null if no match
+   */
+  tryMatchTimeUnit(input, pos, timeUnits, skipWhitespace = false) {
+    let unitPos = pos;
+    if (skipWhitespace) {
+      while (unitPos < input.length && isWhitespace(input[unitPos])) {
+        unitPos++;
+      }
+    }
+    const remaining = input.slice(unitPos);
+    for (const unit of timeUnits) {
+      const candidate = remaining.slice(0, unit.length);
+      const matches = unit.caseInsensitive ? candidate.toLowerCase() === unit.pattern.toLowerCase() : candidate === unit.pattern;
+      if (matches) {
+        if (unit.notFollowedBy) {
+          const nextChar = remaining[unit.length] || "";
+          if (nextChar === unit.notFollowedBy) continue;
+        }
+        if (unit.checkBoundary) {
+          const nextChar = remaining[unit.length] || "";
+          if (isAsciiIdentifierChar(nextChar)) continue;
+        }
+        return { suffix: unit.suffix, endPos: unitPos + unit.length };
+      }
+    }
+    return null;
+  }
+  /**
+   * Parse a base number (sign, integer, decimal) without time units.
+   * Returns the number string and end position.
+   *
+   * @param input - Input string
+   * @param startPos - Start position
+   * @param allowSign - Whether to allow +/- sign (default: true)
+   * @returns Object with number string and end position, or null
+   */
+  parseBaseNumber(input, startPos, allowSign = true) {
+    let pos = startPos;
+    let number = "";
+    if (allowSign && (input[pos] === "-" || input[pos] === "+")) {
+      number += input[pos++];
+    }
+    if (pos >= input.length || !isDigit(input[pos])) {
+      return null;
+    }
+    while (pos < input.length && isDigit(input[pos])) {
+      number += input[pos++];
+    }
+    if (pos < input.length && input[pos] === ".") {
+      number += input[pos++];
+      while (pos < input.length && isDigit(input[pos])) {
+        number += input[pos++];
+      }
+    }
+    if (!number || number === "-" || number === "+") return null;
+    return { number, endPos: pos };
+  }
+  /**
+   * Try to extract a number with native language time units.
+   *
+   * This is a template method that handles the common pattern:
+   * 1. Parse the base number (sign, integer, decimal)
+   * 2. Try to match native language time units
+   * 3. Fall back to standard time units (ms, s, m, h)
+   *
+   * @param input - Input string
+   * @param pos - Start position
+   * @param nativeTimeUnits - Language-specific time unit mappings
+   * @param options - Configuration options
+   * @returns Token if number found, null otherwise
+   */
+  tryNumberWithTimeUnits(input, pos, nativeTimeUnits, options = {}) {
+    const { allowSign = true, skipWhitespace = false } = options;
+    const baseResult = this.parseBaseNumber(input, pos, allowSign);
+    if (!baseResult) return null;
+    let { number, endPos } = baseResult;
+    const allUnits = [...nativeTimeUnits, ..._BaseTokenizer.STANDARD_TIME_UNITS];
+    const timeMatch = this.tryMatchTimeUnit(input, endPos, allUnits, skipWhitespace);
+    if (timeMatch) {
+      number += timeMatch.suffix;
+      endPos = timeMatch.endPos;
+    }
+    return createToken(number, "literal", createPosition(pos, endPos));
+  }
+  /**
+   * Try to extract a URL at the current position.
+   * Handles /path, ./path, ../path, //domain.com, http://, https://
+   */
+  tryUrl(input, pos) {
+    const url = extractUrl(input, pos);
+    if (url) {
+      return createToken(url, "url", createPosition(pos, pos + url.length));
+    }
+    return null;
+  }
+  /**
+   * Try to extract a variable reference (:varname) at the current position.
+   * In hyperscript, :x refers to a local variable named x.
+   */
+  tryVariableRef(input, pos) {
+    if (input[pos] !== ":") return null;
+    if (pos + 1 >= input.length) return null;
+    if (!isAsciiIdentifierChar(input[pos + 1])) return null;
+    let endPos = pos + 1;
+    while (endPos < input.length && isAsciiIdentifierChar(input[endPos])) {
+      endPos++;
+    }
+    const varRef = input.slice(pos, endPos);
+    return createToken(varRef, "identifier", createPosition(pos, endPos));
+  }
+  /**
+   * Try to extract an operator or punctuation token at the current position.
+   * Handles two-character operators (==, !=, etc.) and single-character operators.
+   */
+  tryOperator(input, pos) {
+    const twoChar = input.slice(pos, pos + 2);
+    if (["==", "!=", "<=", ">=", "&&", "||", "->"].includes(twoChar)) {
+      return createToken(twoChar, "operator", createPosition(pos, pos + 2));
+    }
+    const oneChar = input[pos];
+    if (["<", ">", "!", "+", "-", "*", "/", "="].includes(oneChar)) {
+      return createToken(oneChar, "operator", createPosition(pos, pos + 1));
+    }
+    if (["(", ")", "{", "}", ",", ";", ":"].includes(oneChar)) {
+      return createToken(oneChar, "punctuation", createPosition(pos, pos + 1));
+    }
+    return null;
+  }
+  /**
+   * Try to match a multi-character particle from a list.
+   *
+   * Used by languages like Japanese, Korean, and Chinese that have
+   * multi-character particles (e.g., Japanese から, まで, より).
+   *
+   * @param input - Input string
+   * @param pos - Current position
+   * @param particles - Array of multi-character particles to match
+   * @returns Token if matched, null otherwise
+   */
+  tryMultiCharParticle(input, pos, particles) {
+    for (const particle of particles) {
+      if (input.slice(pos, pos + particle.length) === particle) {
+        return createToken(particle, "particle", createPosition(pos, pos + particle.length));
+      }
+    }
+    return null;
+  }
+};
+/**
+ * Configuration for native language time units.
+ * Maps patterns to their standard suffix (ms, s, m, h).
+ */
+_BaseTokenizer.STANDARD_TIME_UNITS = [
+  { pattern: "ms", suffix: "ms", length: 2 },
+  { pattern: "s", suffix: "s", length: 1, checkBoundary: true },
+  { pattern: "m", suffix: "m", length: 1, checkBoundary: true, notFollowedBy: "s" },
+  { pattern: "h", suffix: "h", length: 1, checkBoundary: true }
+];
+var BaseTokenizer = _BaseTokenizer;
+function createSimpleTokenizer(config) {
+  const {
+    language,
+    direction = "ltr",
+    keywords,
+    keywordExtras,
+    keywordProfile,
+    includeOperators = false,
+    caseInsensitive = true,
+    customExtractors
+  } = config;
+  const keywordSet = new Set(caseInsensitive ? keywords.map((k) => k.toLowerCase()) : keywords);
+  class SimpleTokenizer extends BaseTokenizer {
+    constructor() {
+      super();
+      this.language = language;
+      this.direction = direction;
+      if (customExtractors) {
+        this.registerExtractors(customExtractors);
+      }
+      this.registerExtractors(getDefaultExtractors());
+      if (keywordProfile) {
+        this.initializeKeywordsFromProfile(keywordProfile, keywordExtras);
+      }
+    }
+    classifyToken(token) {
+      const lookup = caseInsensitive ? token.toLowerCase() : token;
+      if (keywordSet.has(lookup)) return "keyword";
+      if (this.isKeyword(token)) return "keyword";
+      if (/^\d/.test(token)) return "literal";
+      if (/^['"]/.test(token)) return "literal";
+      if (includeOperators && SIMPLE_TOKENIZER_OPERATOR_SET.has(token)) return "operator";
+      return "identifier";
+    }
+  }
+  return new SimpleTokenizer();
+}
+
+// src/core/tokenization/morphology/types.ts
+function noChange(word) {
+  return { stem: word, confidence: 1 };
+}
+function normalized(stem, confidence, metadata) {
+  if (metadata) {
+    return { stem, confidence, metadata };
+  }
+  return { stem, confidence };
+}
+
+// src/parsing/multi-statement.ts
+function createMultiStatementParser(dsl, config) {
+  return new MultiStatementParserImpl(dsl, config);
+}
+var MultiStatementParserImpl = class {
+  constructor(dsl, config) {
+    this.dsl = dsl;
+    this.config = config;
+  }
+  parse(input, language) {
+    const rawStatements = this.splitStatements(input, language);
+    const statements = [];
+    const errors = [];
+    let previous;
+    for (const raw of rawStatements) {
+      const category = this.classifyLine(raw.text, language);
+      let textToParse = raw.text;
+      if (this.config.continuation) {
+        const resolved = this.resolveContinuation(raw.text, language, previous?.category);
+        if (resolved !== null) {
+          textToParse = resolved;
+        }
+      }
+      if (this.config.preprocessor) {
+        const processed = this.config.preprocessor(textToParse, category, language, {
+          ...previous != null && { previous },
+          lineNumber: raw.line,
+          indent: raw.indent
+        });
+        if (processed === null) continue;
+        textToParse = processed;
+      }
+      try {
+        const node = this.dsl.parse(textToParse, language);
+        const stmt = {
+          node,
+          source: raw.text,
+          line: raw.line,
+          ...category != null && { category },
+          indent: raw.indent
+        };
+        statements.push(stmt);
+        previous = stmt;
+      } catch (err) {
+        errors.push({
+          message: err instanceof Error ? err.message : String(err),
+          line: raw.line,
+          source: raw.text,
+          code: "parse-error"
+        });
+      }
+    }
+    return { statements, errors };
+  }
+  /**
+   * Split input into raw statement lines with metadata.
+   */
+  splitStatements(input, language) {
+    const { mode, trim = true, commentPrefixes = ["--", "//"] } = this.config.split;
+    if (mode === "delimiter") {
+      return this.splitByDelimiter(input, language, trim, commentPrefixes);
+    }
+    const lines = input.split("\n");
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+      const raw = lines[i];
+      const indent = raw.length - raw.trimStart().length;
+      const text = trim ? raw.trim() : raw;
+      if (!text) continue;
+      if (commentPrefixes.some((p) => text.startsWith(p))) continue;
+      result.push({ text, line: i + 1, indent });
+    }
+    return result;
+  }
+  /**
+   * Split by language-specific delimiters.
+   */
+  splitByDelimiter(input, language, trim, commentPrefixes) {
+    const delimiter = this.config.split.delimiters?.[language] ?? this.config.split.defaultDelimiter ?? /,\s*|\n\s*/;
+    const parts = input.split(delimiter);
+    const result = [];
+    for (let i = 0; i < parts.length; i++) {
+      const raw = parts[i];
+      const text = trim ? raw.trim() : raw;
+      if (!text) continue;
+      if (commentPrefixes.some((p) => text.startsWith(p))) continue;
+      result.push({ text, line: i + 1, indent: 0 });
+    }
+    return result;
+  }
+  /**
+   * Classify a line by its keyword category.
+   * Returns the category name or undefined if no match.
+   */
+  classifyLine(line, language) {
+    if (!this.config.keywords) return void 0;
+    const lower = line.toLowerCase();
+    const wordOrder = this.config.keywords.wordOrders?.[language] ?? "SVO";
+    for (const [category, keywordMap] of Object.entries(this.config.keywords.categories)) {
+      const keywords = keywordMap[language] ?? keywordMap["en"] ?? [];
+      for (const kw of keywords) {
+        const kwLower = kw.toLowerCase();
+        if (wordOrder === "SOV") {
+          if (lower.endsWith(kwLower) || lower.startsWith(kwLower)) {
+            return category;
+          }
+        } else {
+          if (lower.startsWith(kwLower)) {
+            return category;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Resolve continuation keywords (e.g., 'and' → re-prefix with previous step type).
+   * Returns the resolved string, or null if not a continuation.
+   */
+  resolveContinuation(text, language, prevCategory) {
+    if (!this.config.continuation || !prevCategory) return null;
+    const contKeywords = this.config.continuation.keywords[language] ?? this.config.continuation.keywords["en"] ?? [];
+    const lower = text.toLowerCase();
+    for (const kw of contKeywords) {
+      const kwLower = kw.toLowerCase();
+      if (lower.startsWith(kwLower)) {
+        const content = text.slice(kw.length).trim();
+        if (!content) return null;
+        if (this.config.continuation.resolve) {
+          return this.config.continuation.resolve(
+            content,
+            prevCategory,
+            language,
+            this.config.keywords?.categories ?? {}
+          );
+        }
+        const prevKeywords = this.config.keywords?.categories[prevCategory]?.[language] ?? this.config.keywords?.categories[prevCategory]?.["en"];
+        if (prevKeywords?.[0]) {
+          return prevKeywords[0] + " " + content;
+        }
+        return null;
+      }
+    }
+    return null;
+  }
+};
+function accumulateBlocks(statements, config) {
+  if (config.nesting === "flat") {
+    return accumulateFlat(statements, config);
+  }
+  return accumulateIndented(statements, config);
+}
+function accumulateFlat(statements, config) {
+  const blocks = [];
+  const orphans = [];
+  let current = null;
+  const flush = () => {
+    if (current) {
+      blocks.push({
+        type: current.type,
+        ...current.name != null && { name: current.name },
+        statements: current.stmts,
+        children: [],
+        line: current.line,
+        indent: current.indent
+      });
+      current = null;
+    }
+  };
+  for (const stmt of statements) {
+    if (stmt.category && config.blockTypes.includes(stmt.category)) {
+      flush();
+      const name = config.extractName?.(stmt.source, stmt.category);
+      current = {
+        type: stmt.category,
+        ...name != null && { name },
+        stmts: [stmt],
+        line: stmt.line,
+        indent: stmt.indent
+      };
+    } else if (current) {
+      current.stmts.push(stmt);
+    } else {
+      orphans.push(stmt);
+    }
+  }
+  flush();
+  return { blocks, orphans };
+}
+function accumulateIndented(statements, config) {
+  const rootBlocks = [];
+  const orphans = [];
+  const stack = [];
+  const flushTo = (targetIndent) => {
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      if (top.indent >= targetIndent) {
+        stack.pop();
+        const block = {
+          type: top.type,
+          ...top.name != null && { name: top.name },
+          statements: top.stmts,
+          children: top.children,
+          line: top.line,
+          indent: top.indent
+        };
+        if (stack.length > 0) {
+          stack[stack.length - 1].children.push(block);
+        } else {
+          rootBlocks.push(block);
+        }
+      } else {
+        break;
+      }
+    }
+  };
+  for (const stmt of statements) {
+    if (stmt.category && config.blockTypes.includes(stmt.category)) {
+      flushTo(stmt.indent);
+      const name = config.extractName?.(stmt.source, stmt.category);
+      stack.push({
+        type: stmt.category,
+        ...name != null && { name },
+        stmts: [stmt],
+        children: [],
+        line: stmt.line,
+        indent: stmt.indent
+      });
+    } else if (stack.length > 0) {
+      stack[stack.length - 1].stmts.push(stmt);
+    } else {
+      orphans.push(stmt);
+    }
+  }
+  flushTo(-1);
+  return { blocks: rootBlocks, orphans };
+}
+export {
+  AOTOrchestrator,
+  BaseTokenizer,
+  CrossDomainDispatcher,
+  DEFAULT_OPERATORS,
+  DEFAULT_PUNCTUATION,
+  DomainAwareScanner,
+  DomainRegistry,
+  GrammarTransformer,
+  IdentifierExtractor,
+  InMemoryDictionary,
+  InMemoryProfileProvider,
+  NullDictionary,
+  NullProfileProvider,
+  NumberExtractor,
+  OperatorExtractor,
+  PatternMatcher,
+  PunctuationExtractor,
+  StringLiteralExtractor,
+  TokenStreamImpl,
+  UnicodeIdentifierExtractor,
+  WhitespaceExtractor,
+  accumulateBlocks,
+  buildPhrase,
+  buildTablesFromProfiles,
+  combineClassifiers,
+  createCommandNode,
+  createCompoundNode,
+  createConditionalNode,
+  createDiagnosticCollector,
+  createEventHandlerNode,
+  createExpression,
+  createLatinCharClassifiers,
+  createLiteral,
+  createLoopNode,
+  createMultiStatementParser,
+  createMultilingualDSL,
+  createPosition,
+  createPropertyPath,
+  createReference,
+  createSchemaRenderer,
+  createSelector,
+  createSimpleTokenizer,
+  createToken,
+  createTokenizerContext,
+  createUnicodeRangeClassifier,
+  defineCommand,
+  defineRole,
+  detectWordOrders,
+  extractCssSelector,
+  extractNumber,
+  extractRoleValue,
+  extractStringLiteral,
+  extractUrl,
+  extractValue,
+  filterBySeverity,
+  fromError,
+  generatePattern,
+  generatePatternVariants,
+  getAllPossessiveKeywords,
+  getDefaultExtractors,
+  getPossessiveReference,
+  insertMarkers,
+  isAsciiIdentifierChar,
+  isAsciiLetter,
+  isBuiltInReference,
+  isCSSPropertyRef,
+  isCSSSelector,
+  isClassName,
+  isContextAwareExtractor,
+  isDigit,
+  isIdSelector,
+  isNumericValue,
+  isPossessiveKeyword,
+  isPossessiveMarker,
+  isPropertyName,
+  isQuote,
+  isSelectorStart,
+  isTypeCompatible,
+  isUrlStart,
+  isVariableRef,
+  isWhitespace,
+  joinTokens,
+  lookupKeyword,
+  lookupMarker,
+  matchBest,
+  matchPattern,
+  noChange,
+  normalized,
+  patternMatcher,
+  reorderRoles,
+  validateValueType,
+  withDefaultExtractors
+};
+//# sourceMappingURL=index.js.map