@lokascript/semantic 1.0.0

package/dist/languages/en.js

@@ -0,0 +1,3491 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/generators/schema-error-codes.ts
+function interpolate(template, params) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => String(params[key] ?? `{${key}}`));
+}
+function createSchemaValidationItem(code, severity, params = {}, role) {
+  const messageTemplate = SchemaErrorMessages[code];
+  const message = interpolate(messageTemplate, params);
+  const suggestionTemplate = SchemaErrorSuggestions[code];
+  const suggestion = suggestionTemplate ? interpolate(suggestionTemplate, params) : void 0;
+  return {
+    code,
+    message,
+    severity,
+    ...role && { role },
+    ...suggestion && { suggestion }
+  };
+}
+var SchemaErrorCodes, SchemaErrorMessages, SchemaErrorSuggestions;
+var init_schema_error_codes = __esm({
+  "src/generators/schema-error-codes.ts"() {
+    "use strict";
+    SchemaErrorCodes = {
+      // Type ambiguity issues
+      AMBIGUOUS_TYPE_LITERAL_SELECTOR: "SCHEMA_AMBIGUOUS_TYPE_LITERAL_SELECTOR",
+      TOO_MANY_EXPECTED_TYPES: "SCHEMA_TOO_MANY_EXPECTED_TYPES",
+      MULTI_TYPE_PATIENT_EXPECTED: "SCHEMA_MULTI_TYPE_PATIENT_EXPECTED",
+      // Role issues
+      NO_REQUIRED_ROLES: "SCHEMA_NO_REQUIRED_ROLES",
+      NO_REQUIRED_ROLES_EXPECTED: "SCHEMA_NO_REQUIRED_ROLES_EXPECTED",
+      // Transition command
+      TRANSITION_PATIENT_ACCEPTS_SELECTOR: "SCHEMA_TRANSITION_PATIENT_ACCEPTS_SELECTOR",
+      TRANSITION_MISSING_GOAL: "SCHEMA_TRANSITION_MISSING_GOAL",
+      // Event handler command
+      EVENT_HANDLER_MISSING_EVENT: "SCHEMA_EVENT_HANDLER_MISSING_EVENT",
+      EVENT_HANDLER_EVENT_NOT_REQUIRED: "SCHEMA_EVENT_HANDLER_EVENT_NOT_REQUIRED",
+      // Conditional commands
+      CONDITIONAL_MISSING_CONDITION: "SCHEMA_CONDITIONAL_MISSING_CONDITION",
+      CONDITIONAL_CONDITION_NOT_REQUIRED: "SCHEMA_CONDITIONAL_CONDITION_NOT_REQUIRED",
+      // Loop commands
+      FOR_LOOP_MISSING_SOURCE: "SCHEMA_FOR_LOOP_MISSING_SOURCE",
+      WHILE_LOOP_MISSING_CONDITION: "SCHEMA_WHILE_LOOP_MISSING_CONDITION"
+    };
+    SchemaErrorMessages = {
+      // Type ambiguity
+      [SchemaErrorCodes.AMBIGUOUS_TYPE_LITERAL_SELECTOR]: "Role '{role}' accepts both 'literal' and 'selector'. This may cause ambiguous type inference for values starting with special characters (* . # etc.).",
+      [SchemaErrorCodes.TOO_MANY_EXPECTED_TYPES]: "Role '{role}' accepts {count} different types. This may make type inference unreliable.",
+      [SchemaErrorCodes.MULTI_TYPE_PATIENT_EXPECTED]: "Role '{role}' accepts multiple types (expected for {command} command).",
+      // Role issues
+      [SchemaErrorCodes.NO_REQUIRED_ROLES]: "Command has no required roles. Is this intentional?",
+      [SchemaErrorCodes.NO_REQUIRED_ROLES_EXPECTED]: "Command has no required roles (expected for {command}).",
+      // Transition
+      [SchemaErrorCodes.TRANSITION_PATIENT_ACCEPTS_SELECTOR]: "Transition command 'patient' role (CSS property name) should only accept 'literal', not 'selector'. CSS property names like 'background-color' are strings, not CSS selectors.",
+      [SchemaErrorCodes.TRANSITION_MISSING_GOAL]: "Transition command requires a 'goal' role for the target value (to <value>). Without it, there's no way to specify what value to transition to.",
+      // Event handler
+      [SchemaErrorCodes.EVENT_HANDLER_MISSING_EVENT]: "Event handler command should have an 'event' role to specify which event to listen for.",
+      [SchemaErrorCodes.EVENT_HANDLER_EVENT_NOT_REQUIRED]: "Event role should be required - every event handler needs an event to listen for.",
+      // Conditionals
+      [SchemaErrorCodes.CONDITIONAL_MISSING_CONDITION]: "Conditional command should have a 'condition' role for the boolean expression.",
+      [SchemaErrorCodes.CONDITIONAL_CONDITION_NOT_REQUIRED]: "Condition role should be required - conditionals need a condition to evaluate.",
+      // Loops
+      [SchemaErrorCodes.FOR_LOOP_MISSING_SOURCE]: "For-loop should have a 'source' role for the collection to iterate over.",
+      [SchemaErrorCodes.WHILE_LOOP_MISSING_CONDITION]: "While-loop should have a 'condition' role for the loop condition."
+    };
+    SchemaErrorSuggestions = {
+      [SchemaErrorCodes.AMBIGUOUS_TYPE_LITERAL_SELECTOR]: "Consider being more specific about which type is expected, or use explicit type markers.",
+      [SchemaErrorCodes.TOO_MANY_EXPECTED_TYPES]: "Consider narrowing the accepted types to improve type inference reliability.",
+      [SchemaErrorCodes.TRANSITION_PATIENT_ACCEPTS_SELECTOR]: "Remove 'selector' from expectedTypes and only accept 'literal'.",
+      [SchemaErrorCodes.TRANSITION_MISSING_GOAL]: "Add a 'goal' role with expectedTypes ['literal', 'variable'].",
+      [SchemaErrorCodes.EVENT_HANDLER_MISSING_EVENT]: "Add an 'event' role with expectedTypes ['literal'].",
+      [SchemaErrorCodes.EVENT_HANDLER_EVENT_NOT_REQUIRED]: "Set required: true on the 'event' role.",
+      [SchemaErrorCodes.CONDITIONAL_MISSING_CONDITION]: "Add a 'condition' role with expectedTypes ['expression'].",
+      [SchemaErrorCodes.CONDITIONAL_CONDITION_NOT_REQUIRED]: "Set required: true on the 'condition' role.",
+      [SchemaErrorCodes.FOR_LOOP_MISSING_SOURCE]: "Add a 'source' role for the collection to iterate over.",
+      [SchemaErrorCodes.WHILE_LOOP_MISSING_CONDITION]: "Add a 'condition' role for the loop continuation condition."
+    };
+  }
+});
+
+// src/generators/schema-validator.ts
+var schema_validator_exports = {};
+__export(schema_validator_exports, {
+  SchemaErrorCodes: () => SchemaErrorCodes,
+  formatValidationResults: () => formatValidationResults,
+  getValidationStats: () => getValidationStats,
+  validateAllSchemas: () => validateAllSchemas,
+  validateCommandSchema: () => validateCommandSchema
+});
+function createValidationResult(action, items) {
+  return {
+    action,
+    items,
+    get notes() {
+      return items.filter((i) => i.severity === "note").map((i) => i.message);
+    },
+    get warnings() {
+      return items.filter((i) => i.severity === "warning").map((i) => i.message);
+    },
+    get errors() {
+      return items.filter((i) => i.severity === "error").map((i) => i.message);
+    }
+  };
+}
+function validateCommandSchema(schema) {
+  const items = [];
+  for (const role of schema.roles) {
+    if (role.expectedTypes.includes("literal") && role.expectedTypes.includes("selector")) {
+      if (role.role === "patient" && MULTI_TYPE_PATIENT_COMMANDS.has(schema.action)) {
+        items.push(
+          createSchemaValidationItem(
+            SchemaErrorCodes.MULTI_TYPE_PATIENT_EXPECTED,
+            "note",
+            { role: role.role, command: schema.action },
+            role.role
+          )
+        );
+      } else {
+        items.push(
+          createSchemaValidationItem(
+            SchemaErrorCodes.AMBIGUOUS_TYPE_LITERAL_SELECTOR,
+            "warning",
+            { role: role.role },
+            role.role
+          )
+        );
+      }
+    }
+    if (role.expectedTypes.length > 3 && !MULTI_TYPE_PATIENT_COMMANDS.has(schema.action)) {
+      items.push(
+        createSchemaValidationItem(
+          SchemaErrorCodes.TOO_MANY_EXPECTED_TYPES,
+          "warning",
+          { role: role.role, count: role.expectedTypes.length },
+          role.role
+        )
+      );
+    }
+  }
+  switch (schema.action) {
+    case "transition":
+      validateTransitionSchema(schema, items);
+      break;
+    case "on":
+      validateEventHandlerSchema(schema, items);
+      break;
+    case "if":
+    case "unless":
+      validateConditionalSchema(schema, items);
+      break;
+    case "repeat":
+    case "for":
+    case "while":
+      validateLoopSchema(schema, items);
+      break;
+  }
+  const requiredRoles = schema.roles.filter((r) => r.required);
+  if (requiredRoles.length === 0) {
+    if (NO_REQUIRED_ROLES_COMMANDS.has(schema.action)) {
+      items.push(
+        createSchemaValidationItem(SchemaErrorCodes.NO_REQUIRED_ROLES_EXPECTED, "note", {
+          command: schema.action
+        })
+      );
+    } else {
+      items.push(createSchemaValidationItem(SchemaErrorCodes.NO_REQUIRED_ROLES, "warning", {}));
+    }
+  }
+  return createValidationResult(schema.action, items);
+}
+function validateTransitionSchema(schema, items) {
+  const patientRole = schema.roles.find((r) => r.role === "patient");
+  const goalRole = schema.roles.find((r) => r.role === "goal");
+  if (patientRole && patientRole.expectedTypes.includes("selector")) {
+    items.push(
+      createSchemaValidationItem(
+        SchemaErrorCodes.TRANSITION_PATIENT_ACCEPTS_SELECTOR,
+        "warning",
+        {},
+        "patient"
+      )
+    );
+  }
+  if (patientRole && !goalRole) {
+    items.push(createSchemaValidationItem(SchemaErrorCodes.TRANSITION_MISSING_GOAL, "error", {}));
+  }
+}
+function validateEventHandlerSchema(schema, items) {
+  const eventRole = schema.roles.find((r) => r.role === "event");
+  if (!eventRole) {
+    items.push(
+      createSchemaValidationItem(SchemaErrorCodes.EVENT_HANDLER_MISSING_EVENT, "warning", {})
+    );
+  }
+  if (eventRole && !eventRole.required) {
+    items.push(
+      createSchemaValidationItem(SchemaErrorCodes.EVENT_HANDLER_EVENT_NOT_REQUIRED, "warning", {})
+    );
+  }
+}
+function validateConditionalSchema(schema, items) {
+  const conditionRole = schema.roles.find((r) => r.role === "condition");
+  if (!conditionRole) {
+    items.push(
+      createSchemaValidationItem(SchemaErrorCodes.CONDITIONAL_MISSING_CONDITION, "warning", {})
+    );
+  }
+  if (conditionRole && !conditionRole.required) {
+    items.push(
+      createSchemaValidationItem(SchemaErrorCodes.CONDITIONAL_CONDITION_NOT_REQUIRED, "warning", {})
+    );
+  }
+}
+function validateLoopSchema(schema, items) {
+  if (schema.action === "for") {
+    const sourceRole = schema.roles.find((r) => r.role === "source");
+    if (!sourceRole) {
+      items.push(
+        createSchemaValidationItem(SchemaErrorCodes.FOR_LOOP_MISSING_SOURCE, "warning", {})
+      );
+    }
+  } else if (schema.action === "while") {
+    const conditionRole = schema.roles.find((r) => r.role === "condition");
+    if (!conditionRole) {
+      items.push(
+        createSchemaValidationItem(SchemaErrorCodes.WHILE_LOOP_MISSING_CONDITION, "warning", {})
+      );
+    }
+  }
+}
+function validateAllSchemas(schemas, options = {}) {
+  const results = /* @__PURE__ */ new Map();
+  const { includeNotes = false } = options;
+  for (const [action, schema] of Object.entries(schemas)) {
+    const validation = validateCommandSchema(schema);
+    const hasWarningsOrErrors = validation.items.some(
+      (i) => i.severity === "warning" || i.severity === "error"
+    );
+    const hasNotes = includeNotes && validation.items.some((i) => i.severity === "note");
+    if (hasWarningsOrErrors || hasNotes) {
+      results.set(action, validation);
+    }
+  }
+  return results;
+}
+function formatValidationResults(validations, options = {}) {
+  const lines = [];
+  const { showNotes = false, showCodes = true } = options;
+  for (const [action, result] of validations) {
+    const errors = result.items.filter((i) => i.severity === "error");
+    const warnings = result.items.filter((i) => i.severity === "warning");
+    const notes = result.items.filter((i) => i.severity === "note");
+    if (errors.length > 0) {
+      lines.push(`  \u274C ${action}:`);
+      for (const item of errors) {
+        const codeStr = showCodes ? ` [${item.code}]` : "";
+        lines.push(`     ERROR${codeStr}: ${item.message}`);
+        if (item.suggestion) {
+          lines.push(`     \u{1F4A1} Suggestion: ${item.suggestion}`);
+        }
+      }
+    }
+    if (warnings.length > 0) {
+      lines.push(`  \u26A0\uFE0F  ${action}:`);
+      for (const item of warnings) {
+        const codeStr = showCodes ? ` [${item.code}]` : "";
+        lines.push(`     ${codeStr ? `${item.code}: ` : ""}${item.message}`);
+        if (item.suggestion) {
+          lines.push(`     \u{1F4A1} ${item.suggestion}`);
+        }
+      }
+    }
+    if (showNotes && notes.length > 0) {
+      lines.push(`  \u2139\uFE0F  ${action}:`);
+      for (const item of notes) {
+        const codeStr = showCodes ? ` [${item.code}]` : "";
+        lines.push(`     ${codeStr ? `${item.code}: ` : ""}${item.message}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function getValidationStats(validations) {
+  let errors = 0;
+  let warnings = 0;
+  let notes = 0;
+  const byCode = {};
+  for (const result of validations.values()) {
+    for (const item of result.items) {
+      if (item.severity === "error") errors++;
+      else if (item.severity === "warning") warnings++;
+      else if (item.severity === "note") notes++;
+      byCode[item.code] = (byCode[item.code] || 0) + 1;
+    }
+  }
+  return {
+    totalCommands: validations.size,
+    errors,
+    warnings,
+    notes,
+    byCode
+  };
+}
+var MULTI_TYPE_PATIENT_COMMANDS, NO_REQUIRED_ROLES_COMMANDS;
+var init_schema_validator = __esm({
+  "src/generators/schema-validator.ts"() {
+    "use strict";
+    init_schema_error_codes();
+    MULTI_TYPE_PATIENT_COMMANDS = /* @__PURE__ */ new Set([
+      "put",
+      "append",
+      "prepend",
+      "log",
+      "throw",
+      "make",
+      "measure",
+      "return",
+      "swap",
+      "morph"
+      // DOM manipulation commands that accept various content types
+    ]);
+    NO_REQUIRED_ROLES_COMMANDS = /* @__PURE__ */ new Set([
+      "compound",
+      "else",
+      "halt",
+      "continue",
+      "async",
+      "init",
+      "settle",
+      "focus",
+      "blur",
+      "return",
+      "js",
+      "measure"
+      // Commands with optional-only roles
+    ]);
+  }
+});
+
+// src/registry.ts
+var tokenizers = /* @__PURE__ */ new Map();
+var profiles = /* @__PURE__ */ new Map();
+var patternCache = /* @__PURE__ */ new Map();
+function registerLanguage(code, tokenizer, profile) {
+  tokenizers.set(code, tokenizer);
+  profiles.set(code, profile);
+  patternCache.delete(code);
+}
+var registeredPatterns = /* @__PURE__ */ new Map();
+function registerPatterns(code, patterns) {
+  registeredPatterns.set(code, patterns);
+  patternCache.delete(code);
+}
+
+// src/tokenizers/base.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(value, kind, position, normalizedOrOptions) {
+  if (typeof normalizedOrOptions === "string") {
+    return { value, kind, position, normalized: normalizedOrOptions };
+  }
+  if (normalizedOrOptions) {
+    const { normalized, stem, stemConfidence } = normalizedOrOptions;
+    const token = { value, kind, position };
+    if (normalized !== void 0) {
+      token.normalized = normalized;
+    }
+    if (stem !== void 0) {
+      token.stem = stem;
+      if (stemConfidence !== void 0) {
+        token.stemConfidence = stemConfidence;
+      }
+    }
+    return token;
+  }
+  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);
+}
+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;
+}
+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();
+  }
+  /**
+   * 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 [normalized, translation] of Object.entries(profile.keywords)) {
+        keywordMap.set(translation.primary, {
+          native: translation.primary,
+          normalized: translation.normalized || normalized
+        });
+        if (translation.alternatives) {
+          for (const alt of translation.alternatives) {
+            keywordMap.set(alt, {
+              native: alt,
+              normalized: translation.normalized || normalized
+            });
+          }
+        }
+      }
+    }
+    if (profile.references) {
+      for (const [normalized, native] of Object.entries(profile.references)) {
+        keywordMap.set(native, { native, normalized });
+      }
+    }
+    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 });
+          }
+        }
+      }
+    }
+    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 normalized = this.removeDiacritics(keyword.native);
+      if (normalized !== keyword.native && !this.profileKeywordMap.has(normalized.toLowerCase())) {
+        this.profileKeywordMap.set(normalized.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;
+
+// src/generators/profiles/english.ts
+var englishProfile = {
+  code: "en",
+  name: "English",
+  nativeName: "English",
+  direction: "ltr",
+  wordOrder: "SVO",
+  markingStrategy: "preposition",
+  usesSpaces: true,
+  // English infinitive and imperative are identical ("toggle", "save", "open")
+  defaultVerbForm: "base",
+  verb: {
+    position: "start",
+    subjectDrop: false
+  },
+  references: {
+    me: "me",
+    it: "it",
+    you: "you",
+    result: "result",
+    event: "event",
+    target: "target",
+    body: "body"
+  },
+  possessive: {
+    marker: "'s",
+    markerPosition: "after-object",
+    specialForms: {
+      me: "my",
+      it: "its",
+      you: "your"
+    },
+    keywords: {
+      my: "me",
+      your: "you",
+      its: "it"
+    }
+  },
+  roleMarkers: {
+    destination: { primary: "on", alternatives: ["to", "from"], position: "before" },
+    source: { primary: "from", position: "before" },
+    patient: { primary: "", position: "before" },
+    style: { primary: "with", alternatives: ["by", "using"], position: "before" },
+    responseType: { primary: "as", position: "before" },
+    method: { primary: "via", alternatives: ["using"], position: "before" }
+  },
+  keywords: {
+    toggle: { primary: "toggle" },
+    add: { primary: "add" },
+    remove: { primary: "remove" },
+    put: { primary: "put" },
+    append: { primary: "append" },
+    prepend: { primary: "prepend" },
+    take: { primary: "take" },
+    make: { primary: "make" },
+    clone: { primary: "clone" },
+    swap: { primary: "swap" },
+    morph: { primary: "morph" },
+    set: { primary: "set" },
+    get: { primary: "get" },
+    increment: { primary: "increment" },
+    decrement: { primary: "decrement" },
+    log: { primary: "log" },
+    show: { primary: "show" },
+    hide: { primary: "hide" },
+    transition: { primary: "transition" },
+    on: { primary: "on" },
+    trigger: { primary: "trigger" },
+    send: { primary: "send" },
+    focus: { primary: "focus" },
+    blur: { primary: "blur" },
+    go: { primary: "go" },
+    wait: { primary: "wait" },
+    fetch: { primary: "fetch" },
+    settle: { primary: "settle" },
+    if: { primary: "if" },
+    when: { primary: "when", normalized: "when" },
+    where: { primary: "where", normalized: "where" },
+    else: { primary: "else" },
+    repeat: { primary: "repeat" },
+    for: { primary: "for" },
+    while: { primary: "while" },
+    continue: { primary: "continue" },
+    halt: { primary: "halt" },
+    throw: { primary: "throw" },
+    call: { primary: "call" },
+    return: { primary: "return" },
+    then: { primary: "then" },
+    and: { primary: "and" },
+    end: { primary: "end" },
+    js: { primary: "js" },
+    async: { primary: "async" },
+    tell: { primary: "tell" },
+    default: { primary: "default" },
+    init: { primary: "init" },
+    behavior: { primary: "behavior" },
+    install: { primary: "install" },
+    measure: { primary: "measure" },
+    into: { primary: "into" },
+    before: { primary: "before" },
+    after: { primary: "after" },
+    until: { primary: "until" },
+    event: { primary: "event" },
+    from: { primary: "from" }
+  }
+};
+
+// src/tokenizers/english.ts
+var ENGLISH_EXTRAS = [
+  // Values/Literals
+  { native: "true", normalized: "true" },
+  { native: "false", normalized: "false" },
+  { native: "null", normalized: "null" },
+  { native: "undefined", normalized: "undefined" },
+  // Positional
+  { native: "first", normalized: "first" },
+  { native: "last", normalized: "last" },
+  { native: "next", normalized: "next" },
+  { native: "previous", normalized: "previous" },
+  { native: "closest", normalized: "closest" },
+  // Events
+  { native: "click", normalized: "click" },
+  { native: "dblclick", normalized: "dblclick" },
+  { native: "mousedown", normalized: "mousedown" },
+  { native: "mouseup", normalized: "mouseup" },
+  { native: "mouseover", normalized: "mouseover" },
+  { native: "mouseout", normalized: "mouseout" },
+  { native: "mouseenter", normalized: "mouseenter" },
+  { native: "mouseleave", normalized: "mouseleave" },
+  { native: "mousemove", normalized: "mousemove" },
+  { native: "keydown", normalized: "keydown" },
+  { native: "keyup", normalized: "keyup" },
+  { native: "keypress", normalized: "keypress" },
+  { native: "input", normalized: "input" },
+  { native: "change", normalized: "change" },
+  { native: "submit", normalized: "submit" },
+  { native: "reset", normalized: "reset" },
+  { native: "load", normalized: "load" },
+  { native: "unload", normalized: "unload" },
+  { native: "scroll", normalized: "scroll" },
+  { native: "resize", normalized: "resize" },
+  { native: "dragstart", normalized: "dragstart" },
+  { native: "drag", normalized: "drag" },
+  { native: "dragend", normalized: "dragend" },
+  { native: "dragenter", normalized: "dragenter" },
+  { native: "dragleave", normalized: "dragleave" },
+  { native: "dragover", normalized: "dragover" },
+  { native: "drop", normalized: "drop" },
+  { native: "touchstart", normalized: "touchstart" },
+  { native: "touchmove", normalized: "touchmove" },
+  { native: "touchend", normalized: "touchend" },
+  { native: "touchcancel", normalized: "touchcancel" },
+  // Prepositions/modifiers not in profile
+  { native: "in", normalized: "in" },
+  { native: "to", normalized: "to" },
+  { native: "at", normalized: "at" },
+  { native: "by", normalized: "by" },
+  { native: "with", normalized: "with" },
+  { native: "without", normalized: "without" },
+  { native: "of", normalized: "of" },
+  { native: "as", normalized: "as" },
+  // Event handling keywords
+  { native: "every", normalized: "every" },
+  { native: "upon", normalized: "upon" },
+  // Control flow helpers not in profile
+  { native: "unless", normalized: "unless" },
+  { native: "forever", normalized: "forever" },
+  { native: "times", normalized: "times" },
+  // Logical
+  { native: "and", normalized: "and" },
+  { native: "or", normalized: "or" },
+  { native: "not", normalized: "not" },
+  { native: "is", normalized: "is" },
+  { native: "exists", normalized: "exists" },
+  { native: "empty", normalized: "empty" },
+  // References not in profile
+  { native: "my", normalized: "my" },
+  { native: "your", normalized: "your" },
+  { native: "its", normalized: "its" },
+  { native: "the", normalized: "the" },
+  { native: "a", normalized: "a" },
+  { native: "an", normalized: "an" },
+  // Swap strategies
+  { native: "delete", normalized: "delete" },
+  { native: "innerHTML", normalized: "innerHTML" },
+  { native: "outerHTML", normalized: "outerHTML" },
+  { native: "beforebegin", normalized: "beforebegin" },
+  { native: "afterend", normalized: "afterend" },
+  { native: "beforeend", normalized: "beforeend" },
+  { native: "afterbegin", normalized: "afterbegin" },
+  // Command synonyms with normalized forms
+  { native: "flip", normalized: "toggle" },
+  { native: "switch", normalized: "toggle" },
+  { native: "increase", normalized: "increment" },
+  { native: "decrease", normalized: "decrement" },
+  { native: "display", normalized: "show" },
+  { native: "reveal", normalized: "show" },
+  { native: "conceal", normalized: "hide" },
+  // British spelling aliases
+  { native: "colour", normalized: "color" },
+  { native: "grey", normalized: "gray" },
+  { native: "centre", normalized: "center" },
+  { native: "behaviour", normalized: "behavior" },
+  { native: "initialise", normalized: "initialize" },
+  { native: "favourite", normalized: "favorite" }
+];
+var EnglishTokenizer = class extends BaseTokenizer {
+  constructor() {
+    super();
+    this.language = "en";
+    this.direction = "ltr";
+    this.initializeKeywordsFromProfile(englishProfile, ENGLISH_EXTRAS);
+  }
+  tokenize(input) {
+    const tokens = [];
+    let pos = 0;
+    while (pos < input.length) {
+      if (isWhitespace(input[pos])) {
+        pos++;
+        continue;
+      }
+      if (isSelectorStart(input[pos])) {
+        const modifierToken = this.tryEventModifier(input, pos);
+        if (modifierToken) {
+          tokens.push(modifierToken);
+          pos = modifierToken.position.end;
+          continue;
+        }
+        if (input[pos] === ".") {
+          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)));
+            pos++;
+            continue;
+          }
+          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)));
+            pos++;
+            continue;
+          }
+        }
+        const selectorToken = this.trySelector(input, pos);
+        if (selectorToken) {
+          tokens.push(selectorToken);
+          pos = selectorToken.position.end;
+          continue;
+        }
+      }
+      if (isQuote(input[pos])) {
+        if (input[pos] === "'" && isPossessiveMarker(input, pos)) {
+          tokens.push(createToken("'s", "punctuation", createPosition(pos, pos + 2)));
+          pos += 2;
+          continue;
+        }
+        const stringToken = this.tryString(input, pos);
+        if (stringToken) {
+          tokens.push(stringToken);
+          pos = stringToken.position.end;
+          continue;
+        }
+      }
+      if (isUrlStart(input, pos)) {
+        const urlToken = this.tryUrl(input, pos);
+        if (urlToken) {
+          tokens.push(urlToken);
+          pos = urlToken.position.end;
+          continue;
+        }
+      }
+      if (isDigit(input[pos]) || input[pos] === "-" && pos + 1 < input.length && isDigit(input[pos + 1])) {
+        const numberToken = this.tryNumber(input, pos);
+        if (numberToken) {
+          tokens.push(numberToken);
+          pos = numberToken.position.end;
+          continue;
+        }
+      }
+      const varToken = this.tryVariableRef(input, pos);
+      if (varToken) {
+        tokens.push(varToken);
+        pos = varToken.position.end;
+        continue;
+      }
+      if (isAsciiIdentifierChar(input[pos])) {
+        const wordToken = this.extractWord(input, pos);
+        if (wordToken) {
+          tokens.push(wordToken);
+          pos = wordToken.position.end;
+          continue;
+        }
+      }
+      const operatorToken = this.tryOperator(input, pos);
+      if (operatorToken) {
+        tokens.push(operatorToken);
+        pos = operatorToken.position.end;
+        continue;
+      }
+      pos++;
+    }
+    return new TokenStreamImpl(tokens, "en");
+  }
+  classifyToken(token) {
+    if (this.isKeyword(token)) return "keyword";
+    if (token.startsWith("#") || token.startsWith(".") || token.startsWith("[")) return "selector";
+    if (token.startsWith('"') || token.startsWith("'")) return "literal";
+    if (/^\d/.test(token)) return "literal";
+    if (["==", "!=", "<=", ">=", "<", ">", "&&", "||", "!"].includes(token)) return "operator";
+    if (token.startsWith("/") || token.startsWith("./") || token.startsWith("http")) return "url";
+    return "identifier";
+  }
+  /**
+   * Extract a word (identifier or keyword) from the input.
+   * Handles namespaced event names like "draggable:start".
+   */
+  extractWord(input, startPos) {
+    let pos = startPos;
+    let word = "";
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      word += input[pos++];
+    }
+    if (!word) return null;
+    if (pos < input.length && input[pos] === ":") {
+      const colonPos = pos;
+      pos++;
+      let namespace = "";
+      while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+        namespace += input[pos++];
+      }
+      if (namespace) {
+        word = word + ":" + namespace;
+      } else {
+        pos = colonPos;
+      }
+    }
+    const kind = this.classifyToken(word);
+    const keywordEntry = this.lookupKeyword(word);
+    const normalized = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
+    if (kind === "identifier") {
+      const classConversion = this.tryConvertToClassSelector(input, pos, word);
+      if (classConversion) {
+        return classConversion.token;
+      }
+    }
+    return createToken(
+      word,
+      kind,
+      createPosition(startPos, pos),
+      normalized
+      // Will be undefined if not a synonym, which is fine
+    );
+  }
+  /**
+   * Try to convert an identifier followed by "class" to a class selector.
+   * E.g., "active class" → ".active"
+   *
+   * This enables natural English syntax like:
+   * - "toggle the active class" → "toggle .active"
+   * - "add the visible class" → "add .visible"
+   */
+  tryConvertToClassSelector(input, pos, word) {
+    let checkPos = pos;
+    while (checkPos < input.length && /\s/.test(input[checkPos])) {
+      checkPos++;
+    }
+    if (input.slice(checkPos, checkPos + 5).toLowerCase() === "class") {
+      const afterClass = checkPos + 5;
+      if (afterClass >= input.length || !isAsciiIdentifierChar(input[afterClass])) {
+        const selectorValue = "." + word;
+        return {
+          token: createToken(selectorValue, "selector", createPosition(pos - word.length, pos)),
+          endPos: pos
+        };
+      }
+    }
+    return null;
+  }
+};
+var englishTokenizer = new EnglishTokenizer();
+
+// src/generators/command-schemas.ts
+var toggleSchema = {
+  action: "toggle",
+  description: "Toggle a class or attribute on/off",
+  category: "dom-class",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The class or attribute to toggle",
+      required: true,
+      expectedTypes: ["selector"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "The target element (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ],
+  // Runtime error documentation
+  errorCodes: ["MISSING_ARGUMENT", "NO_VALID_CLASS_NAMES", "INVALID_CSS_PROPERTY"],
+  preconditions: [
+    {
+      condition: "Command has at least one argument",
+      errorCode: "MISSING_ARGUMENT",
+      message: "toggle command requires an argument"
+    },
+    {
+      condition: "Class names are valid CSS identifiers",
+      errorCode: "NO_VALID_CLASS_NAMES",
+      message: "toggle command: no valid class names found"
+    }
+  ],
+  recoveryHints: {
+    MISSING_ARGUMENT: "Add a class selector (.classname) or attribute to toggle",
+    NO_VALID_CLASS_NAMES: "Ensure class names start with a dot (.) and are valid CSS identifiers",
+    INVALID_CSS_PROPERTY: "Check CSS property name syntax (use kebab-case)"
+  }
+};
+var addSchema = {
+  action: "add",
+  description: "Add a class or attribute to an element",
+  category: "dom-class",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The class or attribute to add",
+      required: true,
+      expectedTypes: ["selector"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "The target element (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ],
+  // Runtime error documentation
+  errorCodes: ["MISSING_ARGUMENT", "NO_VALID_CLASS_NAMES", "PROPERTY_REQUIRES_VALUE"],
+  preconditions: [
+    {
+      condition: "Command has at least one argument",
+      errorCode: "MISSING_ARGUMENT",
+      message: "add command requires an argument"
+    }
+  ],
+  recoveryHints: {
+    MISSING_ARGUMENT: "Add a class selector (.classname) or attribute to add",
+    NO_VALID_CLASS_NAMES: "Ensure class names start with a dot (.) and are valid CSS identifiers",
+    PROPERTY_REQUIRES_VALUE: "When adding a property (*prop), provide a value argument"
+  }
+};
+var removeSchema = {
+  action: "remove",
+  description: "Remove a class or attribute from an element",
+  category: "dom-class",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The class or attribute to remove",
+      required: true,
+      expectedTypes: ["selector"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "source",
+      description: "The element to remove from (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ],
+  // Runtime error documentation
+  errorCodes: ["MISSING_ARGUMENT", "NO_VALID_CLASS_NAMES"],
+  preconditions: [
+    {
+      condition: "Command has at least one argument",
+      errorCode: "MISSING_ARGUMENT",
+      message: "remove command requires an argument"
+    }
+  ],
+  recoveryHints: {
+    MISSING_ARGUMENT: "Add a class selector (.classname) or attribute to remove",
+    NO_VALID_CLASS_NAMES: "Ensure class names start with a dot (.) and are valid CSS identifiers"
+  }
+};
+var putSchema = {
+  action: "put",
+  description: "Put content into a target element or variable",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The content to put",
+      required: true,
+      expectedTypes: ["literal", "selector", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "Where to put the content",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ],
+  // Runtime error documentation
+  errorCodes: [
+    "MISSING_ARGUMENTS",
+    "MISSING_CONTENT",
+    "MISSING_POSITION",
+    "INVALID_POSITION",
+    "NO_TARGET",
+    "NO_ELEMENTS"
+  ],
+  preconditions: [
+    {
+      condition: "Command has content and position arguments",
+      errorCode: "MISSING_ARGUMENTS",
+      message: "put requires arguments"
+    },
+    {
+      condition: "Content to put is specified",
+      errorCode: "MISSING_CONTENT",
+      message: "put requires content"
+    },
+    {
+      condition: "Position keyword is specified (into, before, after, etc.)",
+      errorCode: "MISSING_POSITION",
+      message: "put requires position keyword"
+    }
+  ],
+  recoveryHints: {
+    MISSING_ARGUMENTS: "Use syntax: put <content> into/before/after <target>",
+    MISSING_CONTENT: "Add content to put (string, element, or expression)",
+    MISSING_POSITION: "Add position keyword: into, before, after, at start of, at end of",
+    INVALID_POSITION: "Valid positions: into, before, after, at start of, at end of",
+    NO_TARGET: 'Ensure target element exists or use "me" reference',
+    NO_ELEMENTS: "Check that the selector matches existing elements"
+  }
+};
+var setSchema = {
+  action: "set",
+  description: "Set a property or variable to a value",
+  category: "variable",
+  primaryRole: "destination",
+  roles: [
+    {
+      role: "destination",
+      description: "The property or variable to set",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 1,
+      sovPosition: 1,
+      // Override destination marker for English (remove 'on', use no marker)
+      // Other languages keep their default destination markers
+      markerOverride: {
+        en: ""
+        // No marker before destination in English: "set :x to 5"
+      }
+    },
+    {
+      role: "patient",
+      description: "The value to set",
+      required: true,
+      expectedTypes: ["literal", "expression", "reference"],
+      svoPosition: 2,
+      sovPosition: 2,
+      // Override patient marker for SVO languages with their native prepositions
+      // SOV languages (Korean, Japanese, Turkish) use their default object markers
+      markerOverride: {
+        en: "to",
+        // "set :x to 5"
+        es: "a",
+        // "establecer x a 10"
+        pt: "para",
+        // "definir x para 10"
+        fr: "\xE0",
+        // "définir x à 10"
+        de: "auf",
+        // "setze x auf 10"
+        id: "ke"
+        // "atur x ke 10"
+      }
+    }
+  ],
+  // Runtime error documentation
+  errorCodes: ["MISSING_TARGET", "INVALID_TARGET", "MISSING_VALUE", "INVALID_SYNTAX"],
+  preconditions: [
+    {
+      condition: "Command has a target variable or property",
+      errorCode: "MISSING_TARGET",
+      message: "set command requires a target"
+    },
+    {
+      condition: "Target is a valid variable or property reference",
+      errorCode: "INVALID_TARGET",
+      message: "set command target must be a string or object literal"
+    },
+    {
+      condition: 'Value is specified with "to" keyword',
+      errorCode: "MISSING_VALUE",
+      message: 'set command requires a value (use "to" keyword)'
+    }
+  ],
+  recoveryHints: {
+    MISSING_TARGET: "Add a target: set :variable to value OR set element.property to value",
+    INVALID_TARGET: 'Use local variable (:name), element property (el.prop), or "the X of Y" syntax',
+    MISSING_VALUE: 'Add "to <value>" to specify what to set',
+    INVALID_SYNTAX: "Use syntax: set <target> to <value>"
+  }
+};
+var showSchema = {
+  action: "show",
+  description: "Make an element visible",
+  category: "dom-visibility",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The element to show",
+      required: true,
+      // Changed from false - patient is primary role
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "style",
+      description: "Animation style (fade, slide, etc.)",
+      required: false,
+      expectedTypes: ["literal"],
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var hideSchema = {
+  action: "hide",
+  description: "Make an element invisible",
+  category: "dom-visibility",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The element to hide",
+      required: true,
+      // Changed from false - patient is primary role
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "style",
+      description: "Animation style (fade, slide, etc.)",
+      required: false,
+      expectedTypes: ["literal"],
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var onSchema = {
+  action: "on",
+  description: "Handle an event",
+  category: "event",
+  primaryRole: "event",
+  hasBody: true,
+  roles: [
+    {
+      role: "event",
+      description: "The event to handle",
+      required: true,
+      expectedTypes: ["literal"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "source",
+      description: "The element to listen on (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var triggerSchema = {
+  action: "trigger",
+  description: "Trigger/dispatch an event",
+  category: "event",
+  primaryRole: "event",
+  roles: [
+    {
+      role: "event",
+      description: "The event to trigger (supports namespaced events like draggable:start)",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      // expression for custom/namespaced event names
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "The target element (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var waitSchema = {
+  action: "wait",
+  description: "Wait for a duration or event",
+  category: "async",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "Duration or event to wait for",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var fetchSchema = {
+  action: "fetch",
+  description: "Fetch data from a URL",
+  category: "async",
+  primaryRole: "source",
+  roles: [
+    {
+      role: "source",
+      description: "The URL to fetch from",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "responseType",
+      description: "Response format (json, text, html, blob, etc.)",
+      required: false,
+      expectedTypes: ["literal", "expression"],
+      // json/text/html are identifiers → expression type
+      svoPosition: 2,
+      sovPosition: 2
+    },
+    {
+      role: "method",
+      description: "HTTP method (GET, POST, etc.)",
+      required: false,
+      expectedTypes: ["literal"],
+      svoPosition: 3,
+      sovPosition: 3
+    },
+    {
+      role: "destination",
+      description: "Where to store the result",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 4,
+      sovPosition: 4
+    }
+  ]
+};
+var incrementSchema = {
+  action: "increment",
+  description: "Increment a numeric value",
+  category: "variable",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The value to increment",
+      required: true,
+      expectedTypes: ["selector", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "quantity",
+      description: "Amount to increment by (defaults to 1)",
+      required: false,
+      expectedTypes: ["literal"],
+      default: { type: "literal", value: 1, dataType: "number" },
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var decrementSchema = {
+  action: "decrement",
+  description: "Decrement a numeric value",
+  category: "variable",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The value to decrement",
+      required: true,
+      expectedTypes: ["selector", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "quantity",
+      description: "Amount to decrement by (defaults to 1)",
+      required: false,
+      expectedTypes: ["literal"],
+      default: { type: "literal", value: 1, dataType: "number" },
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var appendSchema = {
+  action: "append",
+  description: "Append content to an element",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The content to append",
+      required: true,
+      expectedTypes: ["literal", "selector", "expression"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "The element to append to",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var prependSchema = {
+  action: "prepend",
+  description: "Prepend content to an element",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The content to prepend",
+      required: true,
+      expectedTypes: ["literal", "selector", "expression"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "The element to prepend to",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var logSchema = {
+  action: "log",
+  description: "Log a value to the console",
+  category: "variable",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The value to log",
+      required: true,
+      expectedTypes: ["literal", "selector", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var getCommandSchema = {
+  action: "get",
+  description: "Get a value from a source",
+  category: "variable",
+  primaryRole: "source",
+  roles: [
+    {
+      role: "source",
+      description: "The source to get from",
+      required: true,
+      expectedTypes: ["selector", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 2,
+      // No marker before source for simple GET pattern: "get #element" not "get from #element"
+      markerOverride: {
+        en: "",
+        es: "",
+        pt: "",
+        fr: "",
+        de: "",
+        ja: "",
+        zh: "",
+        ko: "",
+        ar: "",
+        tr: "",
+        id: ""
+      }
+    },
+    {
+      role: "destination",
+      description: "Where to store the result (optional)",
+      required: false,
+      expectedTypes: ["reference"],
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var takeSchema = {
+  action: "take",
+  description: "Take content from a source element",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The class or element to take",
+      required: true,
+      expectedTypes: ["selector"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "source",
+      description: "The element to take from (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var makeSchema = {
+  action: "make",
+  description: "Create a new element",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The element type or selector to create",
+      required: true,
+      expectedTypes: ["literal", "selector"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var haltSchema = {
+  action: "halt",
+  description: "Halt/stop execution or event propagation",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "What to halt (event, default, bubbling, etc.)",
+      required: false,
+      // Plain "halt" is valid
+      expectedTypes: ["literal", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var settleSchema = {
+  action: "settle",
+  description: "Wait for animations/transitions to settle",
+  category: "async",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The element to settle (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var throwSchema = {
+  action: "throw",
+  description: "Throw an error",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The error message or object to throw",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var sendSchema = {
+  action: "send",
+  description: "Send an event to an element",
+  category: "event",
+  primaryRole: "event",
+  roles: [
+    {
+      role: "event",
+      description: "The event to send",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      // identifiers tokenize as expression
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "The target element (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1,
+      // send uses "to" not "on" for destination: send foo to #target
+      markerOverride: {
+        en: "to",
+        ja: "\u306B",
+        ar: "\u0625\u0644\u0649",
+        es: "a",
+        ko: "\uC5D0\uAC8C",
+        zh: "\u5230",
+        tr: "-e",
+        pt: "para",
+        fr: "\xE0",
+        de: "an",
+        id: "ke",
+        qu: "-man",
+        sw: "kwa"
+      }
+    }
+  ]
+};
+var ifSchema = {
+  action: "if",
+  description: "Conditional execution",
+  category: "control-flow",
+  primaryRole: "condition",
+  hasBody: true,
+  roles: [
+    {
+      role: "condition",
+      description: "The condition to evaluate",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var unlessSchema = {
+  action: "unless",
+  description: "Negated conditional execution (executes when condition is false)",
+  category: "control-flow",
+  primaryRole: "condition",
+  hasBody: true,
+  roles: [
+    {
+      role: "condition",
+      description: "The condition to evaluate (body executes when false)",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var elseSchema = {
+  action: "else",
+  description: "Else branch of conditional",
+  category: "control-flow",
+  primaryRole: "patient",
+  hasBody: true,
+  roles: []
+  // No roles - follows an if
+};
+var repeatSchema = {
+  action: "repeat",
+  description: "Repeat a block of commands",
+  category: "control-flow",
+  primaryRole: "loopType",
+  hasBody: true,
+  roles: [
+    {
+      role: "loopType",
+      description: "Loop variant: forever, times, for, while, until, until-event",
+      required: true,
+      expectedTypes: ["literal"],
+      svoPosition: 0,
+      sovPosition: 0
+    },
+    {
+      role: "quantity",
+      description: "Number of times to repeat",
+      required: false,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "event",
+      description: "Event to wait for (terminates loop)",
+      required: false,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 2,
+      sovPosition: 2
+    },
+    {
+      role: "source",
+      description: "Element to listen for event on",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 3,
+      sovPosition: 3
+    }
+  ],
+  notes: 'Can also use "repeat forever", "repeat until condition", or "repeat until event X from Y"'
+};
+var forSchema = {
+  action: "for",
+  description: "Iterate over a collection",
+  category: "control-flow",
+  primaryRole: "patient",
+  hasBody: true,
+  roles: [
+    {
+      role: "patient",
+      description: "The iteration variable",
+      required: true,
+      expectedTypes: ["reference"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "source",
+      description: "The collection to iterate over",
+      required: true,
+      expectedTypes: ["selector", "reference", "expression"],
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var whileSchema = {
+  action: "while",
+  description: "Loop while condition is true",
+  category: "control-flow",
+  primaryRole: "condition",
+  hasBody: true,
+  roles: [
+    {
+      role: "condition",
+      description: "The condition to check",
+      required: true,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var continueSchema = {
+  action: "continue",
+  description: "Continue to next loop iteration",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: []
+  // No roles
+};
+var goSchema = {
+  action: "go",
+  description: "Navigate to a URL",
+  category: "navigation",
+  primaryRole: "destination",
+  roles: [
+    {
+      role: "destination",
+      description: "The URL to navigate to",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var transitionSchema = {
+  action: "transition",
+  description: "Transition an element with animation",
+  category: "dom-visibility",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The property to transition (opacity, *background-color, etc.)",
+      required: true,
+      expectedTypes: ["literal"],
+      // Only literal - CSS properties are strings, not selectors
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "goal",
+      description: "The target value to transition to",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 2,
+      sovPosition: 3
+    },
+    {
+      role: "destination",
+      description: "The target element (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 3,
+      sovPosition: 1
+    },
+    {
+      role: "duration",
+      description: "Transition duration (over 500ms, for 2 seconds)",
+      required: false,
+      expectedTypes: ["literal"],
+      svoPosition: 4,
+      sovPosition: 4
+    },
+    {
+      role: "style",
+      description: "Easing function (ease-in, linear, etc.)",
+      required: false,
+      expectedTypes: ["literal"],
+      svoPosition: 5,
+      sovPosition: 5
+    }
+  ]
+};
+var cloneSchema = {
+  action: "clone",
+  description: "Clone an element",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The element to clone",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "Where to put the clone",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var focusSchema = {
+  action: "focus",
+  description: "Focus an element",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The element to focus (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var blurSchema = {
+  action: "blur",
+  description: "Remove focus from an element",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The element to blur (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var callSchema = {
+  action: "call",
+  description: "Call a function",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The function to call",
+      required: true,
+      expectedTypes: ["expression", "reference"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var returnSchema = {
+  action: "return",
+  description: "Return a value from a function",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The value to return",
+      required: false,
+      expectedTypes: ["literal", "expression", "reference"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var jsSchema = {
+  action: "js",
+  description: "Execute raw JavaScript code",
+  category: "control-flow",
+  primaryRole: "patient",
+  hasBody: true,
+  roles: [
+    {
+      role: "patient",
+      description: "The JavaScript code to execute",
+      required: false,
+      expectedTypes: ["expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var asyncSchema = {
+  action: "async",
+  description: "Execute commands asynchronously",
+  category: "async",
+  primaryRole: "patient",
+  hasBody: true,
+  roles: []
+};
+var tellSchema = {
+  action: "tell",
+  description: "Execute commands in context of another element",
+  category: "control-flow",
+  primaryRole: "destination",
+  hasBody: true,
+  roles: [
+    {
+      role: "destination",
+      description: "The element to tell",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var defaultSchema = {
+  action: "default",
+  description: "Set a default value for a variable",
+  category: "variable",
+  primaryRole: "destination",
+  roles: [
+    {
+      role: "destination",
+      description: "The variable to set default for",
+      required: true,
+      expectedTypes: ["reference"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "patient",
+      description: "The default value",
+      required: true,
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var initSchema = {
+  action: "init",
+  description: "Initialization block that runs once",
+  category: "control-flow",
+  primaryRole: "patient",
+  hasBody: true,
+  roles: []
+};
+var behaviorSchema = {
+  action: "behavior",
+  description: "Define a reusable behavior",
+  category: "control-flow",
+  primaryRole: "patient",
+  hasBody: true,
+  roles: [
+    {
+      role: "patient",
+      description: "The behavior name (PascalCase identifier)",
+      required: true,
+      expectedTypes: ["literal", "reference", "expression"],
+      // expression for PascalCase identifiers
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var installSchema = {
+  action: "install",
+  description: "Install a behavior on an element",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The behavior name to install",
+      required: true,
+      expectedTypes: ["literal", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 2
+    },
+    {
+      role: "destination",
+      description: "Element to install on (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 1
+    }
+  ]
+};
+var measureSchema = {
+  action: "measure",
+  description: "Measure element dimensions (x, y, width, height, etc.)",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "Property to measure (x, y, width, height, top, left, etc.)",
+      required: false,
+      // Plain "measure" is valid, defaults to bounds
+      expectedTypes: ["literal", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "source",
+      description: "Element to measure (defaults to me)",
+      required: false,
+      expectedTypes: ["selector", "reference"],
+      default: { type: "reference", value: "me" },
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var swapSchema = {
+  action: "swap",
+  description: "Swap DOM content using various strategies (innerHTML, outerHTML, delete, etc.)",
+  category: "dom-content",
+  primaryRole: "destination",
+  roles: [
+    {
+      role: "method",
+      description: "The swap strategy (innerHTML, outerHTML, beforebegin, afterend, delete)",
+      required: false,
+      expectedTypes: ["literal"],
+      svoPosition: 1,
+      sovPosition: 3
+    },
+    {
+      role: "destination",
+      description: "The element to swap content in/for",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 2,
+      sovPosition: 1
+    },
+    {
+      role: "patient",
+      description: "The content to swap in (optional for delete)",
+      required: false,
+      expectedTypes: ["literal", "expression", "selector"],
+      svoPosition: 3,
+      sovPosition: 2
+    }
+  ]
+};
+var morphSchema = {
+  action: "morph",
+  description: "Morph an element into another using DOM diffing",
+  category: "dom-content",
+  primaryRole: "destination",
+  roles: [
+    {
+      role: "destination",
+      description: "The element to morph",
+      required: true,
+      expectedTypes: ["selector", "reference"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "patient",
+      description: "The target content/element to morph into",
+      required: true,
+      expectedTypes: ["literal", "expression", "selector"],
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var commandSchemas = {
+  // Original schemas
+  toggle: toggleSchema,
+  add: addSchema,
+  remove: removeSchema,
+  put: putSchema,
+  set: setSchema,
+  show: showSchema,
+  hide: hideSchema,
+  on: onSchema,
+  trigger: triggerSchema,
+  wait: waitSchema,
+  fetch: fetchSchema,
+  increment: incrementSchema,
+  decrement: decrementSchema,
+  append: appendSchema,
+  prepend: prependSchema,
+  // Batch 1 - Simple Commands
+  log: logSchema,
+  get: getCommandSchema,
+  take: takeSchema,
+  make: makeSchema,
+  halt: haltSchema,
+  settle: settleSchema,
+  throw: throwSchema,
+  send: sendSchema,
+  // Batch 2 - Control Flow
+  if: ifSchema,
+  unless: unlessSchema,
+  else: elseSchema,
+  repeat: repeatSchema,
+  for: forSchema,
+  while: whileSchema,
+  continue: continueSchema,
+  // Batch 3 - DOM & Navigation
+  go: goSchema,
+  transition: transitionSchema,
+  clone: cloneSchema,
+  focus: focusSchema,
+  blur: blurSchema,
+  // Batch 4 - Advanced
+  call: callSchema,
+  return: returnSchema,
+  js: jsSchema,
+  async: asyncSchema,
+  tell: tellSchema,
+  default: defaultSchema,
+  init: initSchema,
+  behavior: behaviorSchema,
+  install: installSchema,
+  measure: measureSchema,
+  // Batch 5 - DOM Content Manipulation
+  swap: swapSchema,
+  morph: morphSchema,
+  // Meta commands (for compound structures)
+  compound: {
+    action: "compound",
+    description: "A compound node representing chained statements",
+    primaryRole: "patient",
+    // Compound nodes don't have a traditional primary role
+    category: "control-flow",
+    hasBody: true,
+    roles: []
+  }
+};
+function getDefinedSchemas() {
+  return Object.values(commandSchemas).filter((s) => s.roles.length > 0);
+}
+if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+  Promise.resolve().then(() => (init_schema_validator(), schema_validator_exports)).then(({ validateAllSchemas: validateAllSchemas2, formatValidationResults: formatValidationResults2 }) => {
+    const validations = validateAllSchemas2(commandSchemas);
+    if (validations.size > 0) {
+      console.warn("[SCHEMA VALIDATION] Found issues in command schemas:");
+      console.warn(formatValidationResults2(validations));
+      console.warn("\nThese warnings help identify potential schema design issues.");
+      console.warn("Fix them to improve type inference and avoid runtime bugs.");
+    }
+  }).catch((err) => {
+    console.debug("Schema validation skipped:", err);
+  });
+}
+
+// src/parser/utils/role-positioning.ts
+function sortRolesByWordOrder(roles, wordOrder) {
+  const sortKey = wordOrder === "SOV" ? "sovPosition" : "svoPosition";
+  return [...roles].sort((a, b) => {
+    const aPos = a[sortKey] ?? 99;
+    const bPos = b[sortKey] ?? 99;
+    return aPos - bPos;
+  });
+}
+
+// src/parser/utils/marker-resolution.ts
+function resolveMarkerForRole(roleSpec, profile) {
+  const overrideMarker = roleSpec.markerOverride?.[profile.code];
+  const defaultMarker = profile.roleMarkers[roleSpec.role];
+  if (overrideMarker !== void 0) {
+    return {
+      primary: overrideMarker,
+      position: defaultMarker?.position ?? "before",
+      isOverride: true
+    };
+  }
+  if (defaultMarker && defaultMarker.primary) {
+    const result = {
+      primary: defaultMarker.primary,
+      position: defaultMarker.position,
+      isOverride: false
+    };
+    if (defaultMarker.alternatives) {
+      result.alternatives = defaultMarker.alternatives;
+    }
+    return result;
+  }
+  return null;
+}
+
+// src/generators/pattern-generator.ts
+var defaultConfig = {
+  basePriority: 100,
+  generateSimpleVariants: true,
+  generateAlternatives: 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);
+  const extraction = buildExtractionRulesWithDefaults(schema, profile);
+  const format = buildFormatString(schema, profile, keyword);
+  return {
+    id,
+    language: profile.code,
+    command: schema.action,
+    priority,
+    template: {
+      format,
+      tokens
+    },
+    extraction
+  };
+}
+function generateSimplePattern(schema, profile, config = defaultConfig) {
+  const optionalRoles = schema.roles.filter((r) => !r.required);
+  if (optionalRoles.length === 0) {
+    return null;
+  }
+  const requiredRoles = schema.roles.filter((r) => r.required);
+  const simpleSchema = {
+    ...schema,
+    roles: requiredRoles
+  };
+  const pattern = generatePattern(simpleSchema, profile, config);
+  return {
+    ...pattern,
+    id: `${schema.action}-${profile.code}-simple`,
+    priority: (config.basePriority ?? 100) - 5,
+    // Lower priority than full pattern (was -10)
+    extraction: buildExtractionRulesWithDefaults(schema, profile)
+  };
+}
+function generatePatternVariants(schema, profile, config = defaultConfig) {
+  const patterns = [];
+  patterns.push(generatePattern(schema, profile, config));
+  if (config.generateSimpleVariants) {
+    const simple = generateSimplePattern(schema, profile, config);
+    if (simple) {
+      patterns.push(simple);
+    }
+  }
+  return patterns;
+}
+function generatePatternsForLanguage(profile, config = defaultConfig) {
+  const patterns = [];
+  const schemas = getDefinedSchemas();
+  for (const schema of schemas) {
+    if (!profile.keywords[schema.action]) {
+      continue;
+    }
+    const variants = generatePatternVariants(schema, profile, config);
+    patterns.push(...variants);
+  }
+  return patterns;
+}
+function buildTokens(schema, profile, keyword) {
+  const tokens = [];
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  const roleTokens = buildRoleTokens(schema, profile);
+  switch (profile.wordOrder) {
+    case "SVO":
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+      break;
+    case "SOV":
+      tokens.push(...roleTokens);
+      tokens.push(verbToken);
+      break;
+    case "VSO":
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+      break;
+    default:
+      tokens.push(verbToken);
+      tokens.push(...roleTokens);
+  }
+  return tokens;
+}
+function buildRoleTokens(schema, profile) {
+  const tokens = [];
+  const sortedRoles = sortRolesByWordOrder(schema.roles, profile.wordOrder);
+  for (const roleSpec of sortedRoles) {
+    const roleToken = buildRoleToken(roleSpec, profile);
+    if (!roleSpec.required) {
+      tokens.push({
+        type: "group",
+        optional: true,
+        tokens: roleToken
+      });
+    } else {
+      tokens.push(...roleToken);
+    }
+  }
+  return tokens;
+}
+function buildRoleToken(roleSpec, profile) {
+  const tokens = [];
+  const overrideMarker = roleSpec.markerOverride?.[profile.code];
+  const defaultMarker = profile.roleMarkers[roleSpec.role];
+  const roleValueToken = {
+    type: "role",
+    role: roleSpec.role,
+    optional: !roleSpec.required,
+    expectedTypes: roleSpec.expectedTypes
+  };
+  if (overrideMarker !== void 0) {
+    const position = defaultMarker?.position ?? "before";
+    if (position === "before") {
+      if (overrideMarker) {
+        tokens.push({ type: "literal", value: overrideMarker });
+      }
+      tokens.push(roleValueToken);
+    } else {
+      tokens.push(roleValueToken);
+      if (overrideMarker) {
+        tokens.push({ type: "literal", value: overrideMarker });
+      }
+    }
+  } else if (defaultMarker) {
+    if (defaultMarker.position === "before") {
+      if (defaultMarker.primary) {
+        const markerToken = defaultMarker.alternatives ? {
+          type: "literal",
+          value: defaultMarker.primary,
+          alternatives: defaultMarker.alternatives
+        } : { type: "literal", value: defaultMarker.primary };
+        tokens.push(markerToken);
+      }
+      tokens.push(roleValueToken);
+    } else {
+      tokens.push(roleValueToken);
+      const markerToken = defaultMarker.alternatives ? {
+        type: "literal",
+        value: defaultMarker.primary,
+        alternatives: defaultMarker.alternatives
+      } : { type: "literal", value: defaultMarker.primary };
+      tokens.push(markerToken);
+    }
+  } else {
+    tokens.push(roleValueToken);
+  }
+  return tokens;
+}
+function buildExtractionRules(schema, profile) {
+  const rules = {};
+  for (const roleSpec of schema.roles) {
+    const overrideMarker = roleSpec.markerOverride?.[profile.code];
+    const defaultMarker = profile.roleMarkers[roleSpec.role];
+    if (overrideMarker !== void 0) {
+      rules[roleSpec.role] = overrideMarker ? { marker: overrideMarker } : {};
+    } else if (defaultMarker && defaultMarker.primary) {
+      rules[roleSpec.role] = defaultMarker.alternatives ? { marker: defaultMarker.primary, markerAlternatives: defaultMarker.alternatives } : { marker: defaultMarker.primary };
+    } else {
+      rules[roleSpec.role] = {};
+    }
+  }
+  return rules;
+}
+function buildExtractionRulesWithDefaults(schema, profile) {
+  const baseRules = buildExtractionRules(schema, profile);
+  const rules = {};
+  for (const roleSpec of schema.roles) {
+    const baseRule = baseRules[roleSpec.role] || {};
+    if (!roleSpec.required && roleSpec.default) {
+      rules[roleSpec.role] = { ...baseRule, default: roleSpec.default };
+    } else {
+      rules[roleSpec.role] = baseRule;
+    }
+  }
+  return rules;
+}
+function buildFormatString(schema, profile, keyword) {
+  const parts = [];
+  const sortedRoles = sortRolesByWordOrder(schema.roles, profile.wordOrder);
+  const roleParts = sortedRoles.map((roleSpec) => {
+    const resolved = resolveMarkerForRole(roleSpec, profile);
+    let part = "";
+    if (resolved && resolved.primary) {
+      if (resolved.position === "before") {
+        part = `${resolved.primary} {${roleSpec.role}}`;
+      } else {
+        part = `{${roleSpec.role}} ${resolved.primary}`;
+      }
+    } else {
+      part = `{${roleSpec.role}}`;
+    }
+    return roleSpec.required ? part : `[${part}]`;
+  });
+  switch (profile.wordOrder) {
+    case "SVO":
+    case "VSO":
+      parts.push(keyword.primary, ...roleParts);
+      break;
+    case "SOV":
+      parts.push(...roleParts, keyword.primary);
+      break;
+    default:
+      parts.push(keyword.primary, ...roleParts);
+  }
+  return parts.join(" ");
+}
+
+// src/patterns/toggle/en.ts
+function getTogglePatternsEn() {
+  return [
+    {
+      id: "toggle-en-full",
+      language: "en",
+      command: "toggle",
+      priority: 100,
+      template: {
+        format: "toggle {patient} on {target}",
+        tokens: [
+          { type: "literal", value: "toggle" },
+          { type: "role", role: "patient" },
+          {
+            type: "group",
+            optional: true,
+            tokens: [
+              { type: "literal", value: "on", alternatives: ["from"] },
+              { type: "role", role: "destination" }
+            ]
+          }
+        ]
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: {
+          marker: "on",
+          markerAlternatives: ["from"],
+          default: { type: "reference", value: "me" }
+        }
+      }
+    },
+    {
+      id: "toggle-en-simple",
+      language: "en",
+      command: "toggle",
+      priority: 90,
+      template: {
+        format: "toggle {patient}",
+        tokens: [
+          { type: "literal", value: "toggle" },
+          { type: "role", role: "patient" }
+        ]
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { default: { type: "reference", value: "me" } }
+      }
+    }
+  ];
+}
+
+// src/patterns/put/en.ts
+function getPutPatternsEn() {
+  return [
+    {
+      id: "put-en-into",
+      language: "en",
+      command: "put",
+      priority: 100,
+      template: {
+        format: "put {patient} into {destination}",
+        tokens: [
+          { type: "literal", value: "put" },
+          { type: "role", role: "patient" },
+          { type: "literal", value: "into", alternatives: ["in", "to"] },
+          { type: "role", role: "destination" }
+        ]
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: "into", markerAlternatives: ["in", "to"] }
+      }
+    },
+    {
+      id: "put-en-before",
+      language: "en",
+      command: "put",
+      priority: 95,
+      template: {
+        format: "put {patient} before {destination}",
+        tokens: [
+          { type: "literal", value: "put" },
+          { type: "role", role: "patient" },
+          { type: "literal", value: "before" },
+          { type: "role", role: "destination" }
+        ]
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: "before" },
+        manner: { default: { type: "literal", value: "before" } }
+      }
+    },
+    {
+      id: "put-en-after",
+      language: "en",
+      command: "put",
+      priority: 95,
+      template: {
+        format: "put {patient} after {destination}",
+        tokens: [
+          { type: "literal", value: "put" },
+          { type: "role", role: "patient" },
+          { type: "literal", value: "after" },
+          { type: "role", role: "destination" }
+        ]
+      },
+      extraction: {
+        patient: { position: 1 },
+        destination: { marker: "after" },
+        manner: { default: { type: "literal", value: "after" } }
+      }
+    }
+  ];
+}
+
+// src/patterns/event-handler/en.ts
+function getEventHandlerPatternsEn() {
+  return [
+    {
+      id: "event-en-when-source",
+      language: "en",
+      command: "on",
+      priority: 115,
+      template: {
+        format: "when {event} from {source} {body}",
+        tokens: [
+          { type: "literal", value: "when" },
+          { type: "role", role: "event" },
+          { type: "literal", value: "from" },
+          { type: "role", role: "source" }
+        ]
+      },
+      extraction: {
+        event: { position: 1 },
+        source: { marker: "from" }
+      }
+    },
+    {
+      id: "event-en-when",
+      language: "en",
+      command: "on",
+      priority: 105,
+      template: {
+        format: "when {event} {body}",
+        tokens: [
+          { type: "literal", value: "when" },
+          { type: "role", role: "event" }
+        ]
+      },
+      extraction: {
+        event: { position: 1 }
+      }
+    },
+    {
+      id: "event-en-source",
+      language: "en",
+      command: "on",
+      priority: 110,
+      template: {
+        format: "on {event} from {source} {body}",
+        tokens: [
+          { type: "literal", value: "on" },
+          { type: "role", role: "event" },
+          { type: "literal", value: "from" },
+          { type: "role", role: "source" }
+        ]
+      },
+      extraction: {
+        event: { position: 1 },
+        source: { marker: "from" }
+      }
+    },
+    {
+      id: "event-en-standard",
+      language: "en",
+      command: "on",
+      priority: 100,
+      template: {
+        format: "on {event} {body}",
+        tokens: [
+          { type: "literal", value: "on" },
+          { type: "role", role: "event" }
+        ]
+      },
+      extraction: {
+        event: { position: 1 }
+      }
+    },
+    {
+      id: "event-en-upon",
+      language: "en",
+      command: "on",
+      priority: 98,
+      template: {
+        format: "upon {event} {body}",
+        tokens: [
+          { type: "literal", value: "upon" },
+          { type: "role", role: "event" }
+        ]
+      },
+      extraction: {
+        event: { position: 1 }
+      }
+    },
+    {
+      id: "event-en-if",
+      language: "en",
+      command: "on",
+      priority: 95,
+      template: {
+        format: "if {event} {body}",
+        tokens: [
+          { type: "literal", value: "if" },
+          { type: "role", role: "event" }
+        ]
+      },
+      extraction: {
+        event: { position: 1 }
+      }
+    }
+  ];
+}
+
+// src/patterns/en.ts
+var fetchWithResponseTypeEnglish = {
+  id: "fetch-en-with-response-type",
+  language: "en",
+  command: "fetch",
+  priority: 90,
+  template: {
+    format: "fetch {source} as {responseType}",
+    tokens: [
+      { type: "literal", value: "fetch" },
+      { type: "role", role: "source", expectedTypes: ["literal", "expression"] },
+      { type: "literal", value: "as" },
+      { type: "role", role: "responseType", expectedTypes: ["literal", "expression"] }
+    ]
+  },
+  extraction: {
+    source: { position: 1 },
+    responseType: { marker: "as" }
+  }
+};
+var fetchSimpleEnglish = {
+  id: "fetch-en-simple",
+  language: "en",
+  command: "fetch",
+  priority: 80,
+  template: {
+    format: "fetch {source}",
+    tokens: [
+      { type: "literal", value: "fetch" },
+      { type: "role", role: "source" }
+    ]
+  },
+  extraction: {
+    source: { position: 1 }
+  }
+};
+var swapSimpleEnglish = {
+  id: "swap-en-handcrafted",
+  language: "en",
+  command: "swap",
+  priority: 110,
+  template: {
+    format: "swap {method} {destination}",
+    tokens: [
+      { type: "literal", value: "swap" },
+      { type: "role", role: "method" },
+      { type: "role", role: "destination" }
+    ]
+  },
+  extraction: {
+    method: { position: 1 },
+    destination: { position: 2 }
+  }
+};
+var repeatUntilEventFromEnglish = {
+  id: "repeat-en-until-event-from",
+  language: "en",
+  command: "repeat",
+  priority: 120,
+  template: {
+    format: "repeat until event {event} from {source}",
+    tokens: [
+      { type: "literal", value: "repeat" },
+      { type: "literal", value: "until" },
+      { type: "literal", value: "event" },
+      { type: "role", role: "event", expectedTypes: ["literal", "expression"] },
+      { type: "literal", value: "from" },
+      { type: "role", role: "source", expectedTypes: ["selector", "reference", "expression"] }
+    ]
+  },
+  extraction: {
+    event: { marker: "event" },
+    source: { marker: "from" },
+    loopType: { default: { type: "literal", value: "until-event" } }
+  }
+};
+var repeatUntilEventEnglish = {
+  id: "repeat-en-until-event",
+  language: "en",
+  command: "repeat",
+  priority: 110,
+  template: {
+    format: "repeat until event {event}",
+    tokens: [
+      { type: "literal", value: "repeat" },
+      { type: "literal", value: "until" },
+      { type: "literal", value: "event" },
+      { type: "role", role: "event", expectedTypes: ["literal", "expression"] }
+    ]
+  },
+  extraction: {
+    event: { marker: "event" },
+    loopType: { default: { type: "literal", value: "until-event" } }
+  }
+};
+var setPossessiveEnglish = {
+  id: "set-en-possessive",
+  language: "en",
+  command: "set",
+  priority: 100,
+  template: {
+    format: "set {destination} to {patient}",
+    tokens: [
+      { type: "literal", value: "set" },
+      {
+        type: "role",
+        role: "destination",
+        expectedTypes: ["property-path", "selector", "reference", "expression"]
+      },
+      { type: "literal", value: "to" },
+      { type: "role", role: "patient", expectedTypes: ["literal", "expression", "reference"] }
+    ]
+  },
+  extraction: {
+    destination: { position: 1 },
+    patient: { marker: "to" }
+  }
+};
+var forEnglish = {
+  id: "for-en-basic",
+  language: "en",
+  command: "for",
+  priority: 100,
+  template: {
+    format: "for {patient} in {source}",
+    tokens: [
+      { type: "literal", value: "for" },
+      { type: "role", role: "patient", expectedTypes: ["expression", "reference"] },
+      { type: "literal", value: "in" },
+      { type: "role", role: "source", expectedTypes: ["selector", "expression", "reference"] }
+    ]
+  },
+  extraction: {
+    patient: { position: 1 },
+    source: { marker: "in" },
+    loopType: { default: { type: "literal", value: "for" } }
+  }
+};
+var ifEnglish = {
+  id: "if-en-basic",
+  language: "en",
+  command: "if",
+  priority: 100,
+  template: {
+    format: "if {condition}",
+    tokens: [
+      { type: "literal", value: "if" },
+      { type: "role", role: "condition", expectedTypes: ["expression", "reference", "selector"] }
+    ]
+  },
+  extraction: {
+    condition: { position: 1 }
+  }
+};
+var unlessEnglish = {
+  id: "unless-en-basic",
+  language: "en",
+  command: "unless",
+  priority: 100,
+  template: {
+    format: "unless {condition}",
+    tokens: [
+      { type: "literal", value: "unless" },
+      { type: "role", role: "condition", expectedTypes: ["expression", "reference", "selector"] }
+    ]
+  },
+  extraction: {
+    condition: { position: 1 }
+  }
+};
+var temporalInEnglish = {
+  id: "temporal-en-in",
+  language: "en",
+  command: "wait",
+  priority: 95,
+  template: {
+    format: "in {duration}",
+    tokens: [
+      { type: "literal", value: "in" },
+      { type: "role", role: "duration", expectedTypes: ["literal", "expression"] }
+    ]
+  },
+  extraction: {
+    duration: { position: 1 }
+  }
+};
+var temporalAfterEnglish = {
+  id: "temporal-en-after",
+  language: "en",
+  command: "wait",
+  priority: 95,
+  template: {
+    format: "after {duration}",
+    tokens: [
+      { type: "literal", value: "after" },
+      { type: "role", role: "duration", expectedTypes: ["literal", "expression"] }
+    ]
+  },
+  extraction: {
+    duration: { position: 1 }
+  }
+};
+function buildEnglishPatterns() {
+  const patterns = [];
+  patterns.push(...getTogglePatternsEn());
+  patterns.push(...getPutPatternsEn());
+  patterns.push(...getEventHandlerPatternsEn());
+  patterns.push(
+    fetchWithResponseTypeEnglish,
+    fetchSimpleEnglish,
+    swapSimpleEnglish,
+    repeatUntilEventFromEnglish,
+    repeatUntilEventEnglish,
+    setPossessiveEnglish,
+    forEnglish,
+    ifEnglish,
+    unlessEnglish,
+    temporalInEnglish,
+    temporalAfterEnglish
+  );
+  const generatedPatterns = generatePatternsForLanguage(englishProfile);
+  patterns.push(...generatedPatterns);
+  return patterns;
+}
+
+// src/languages/en.ts
+registerLanguage("en", englishTokenizer, englishProfile);
+registerPatterns("en", buildEnglishPatterns());
+export {
+  englishProfile,
+  englishTokenizer
+};
+//# sourceMappingURL=en.js.map