@lokascript/compilation-service 2.8.0 → 2.9.0

package/dist/{dist-DIXYSN7G.js → dist-EFDE4LTF.js}

@@ -26086,6 +26086,26 @@ function filterBySeverity(diagnostics, severity) {
   return diagnostics.filter((d) => d.severity === severity);
 }
 function defineCommand(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    throw new TypeError(`defineCommand: expected a schema object, got ${describeValue(schema)}.`);
+  }
+  if (typeof schema.action !== "string" || schema.action.length === 0) {
+    throw new TypeError(
+      `defineCommand: 'action' must be a non-empty string (got ${describeValue(schema.action)}).`
+    );
+  }
+  if (!Array.isArray(schema.roles)) {
+    throw new TypeError(
+      `defineCommand("${schema.action}"): 'roles' must be an array of RoleSpec (got ${describeValue(schema.roles)}). Build entries with defineRole().`
+    );
+  }
+  for (const [index2, role] of schema.roles.entries()) {
+    if (typeof role !== "object" || role === null || typeof role.role !== "string") {
+      throw new TypeError(
+        `defineCommand("${schema.action}"): roles[${index2}] must be a RoleSpec with a string 'role' field (got ${describeValue(role)}). Build it with defineRole().`
+      );
+    }
+  }
   return {
     description: schema.description || `${schema.action} command`,
     category: schema.category || "general",
@@ -26105,8 +26125,16 @@ function defineRole(role) {
   };
 }
 function getRoleSpec(schema, role) {
+  if (!schema || !Array.isArray(schema.roles)) return void 0;
   return schema.roles.find((r) => r.role === role);
 }
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `an array of length ${value.length}`;
+  if (typeof value === "string") return `the string ${JSON.stringify(value)}`;
+  if (typeof value === "object") return "an object";
+  return typeof value === "undefined" ? "undefined" : String(value);
+}
 function inferRolesFromSchema(schema, args, modifiers, target, adapter) {
   const roles = {};
   const skipTokens = new Set(schema.argSkipTokens ?? []);
@@ -28634,10 +28662,12 @@ function buildTokens$1(schema, profile, keyword, alternatives) {
       addRoleWithMarker(tokens, role, profile);
     }
   } else if (profile.wordOrder === "SOV") {
+    const preVerb = [];
+    const postVerb = [];
     for (const role of sortedRoles) {
-      addRoleWithMarker(tokens, role, profile);
+      addRoleWithMarker(role.sovSlot === "postVerb" ? postVerb : preVerb, role, profile);
     }
-    tokens.push(keywordToken);
+    tokens.push(...preVerb, keywordToken, ...postVerb);
   } else if (profile.wordOrder === "VSO") {
     tokens.push(keywordToken);
     for (const role of sortedRoles) {
@@ -28720,35 +28750,145 @@ function buildExtractionRules$1(schema, profile) {
   return rules;
 }
 function buildFormatString$1(schema, profile, keyword) {
-  const parts = [];
-  if (profile.wordOrder === "SVO" || profile.wordOrder === "VSO") {
-    parts.push(keyword);
-  }
+  const isSOV = profile.wordOrder === "SOV";
+  const preVerb = [];
+  const postVerb = [];
   const sortedRoles = sortRolesByWordOrder$1(schema.roles, profile.wordOrder);
   for (const role of sortedRoles) {
     const marker = getMarkerForRole(role, profile);
     const roleName = `{${role.role}}`;
+    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
     if (marker) {
       const markerInfo = profile.roleMarkers?.[role.role];
       if (markerInfo?.position === "after") {
-        parts.push(`${roleName} ${marker}`);
+        bucket.push(`${roleName} ${marker}`);
       } else {
-        parts.push(`${marker} ${roleName}`);
+        bucket.push(`${marker} ${roleName}`);
       }
     } else {
-      parts.push(roleName);
+      bucket.push(roleName);
     }
   }
-  if (profile.wordOrder === "SOV") {
-    parts.push(keyword);
-  }
-  return parts.join(" ");
+  return (isSOV ? [...preVerb, keyword, ...postVerb] : [keyword, ...preVerb, ...postVerb]).join(
+    " "
+  );
 }
 function generatePatternVariants$1(schema, profile, config2 = defaultConfig$1) {
   const patterns = [];
   patterns.push(generatePattern$1(schema, profile, config2));
   return patterns;
 }
+function lookupKeyword(keywords, action, language) {
+  return keywords[action]?.[language] ?? action;
+}
+function lookupMarker(markers, marker, language) {
+  return markers[marker]?.[language] ?? marker;
+}
+function buildPhrase(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function buildTablesFromProfiles(schemas, profiles2) {
+  const keywords = {};
+  const markers = {};
+  for (const profile of profiles2) {
+    for (const [action, kw] of Object.entries(profile.keywords)) {
+      if (!keywords[action]) keywords[action] = {};
+      keywords[action][profile.code] = kw.primary;
+    }
+  }
+  for (const schema of schemas) {
+    for (const role of schema.roles) {
+      if (role.markerOverride) {
+        const markerKey = role.role;
+        if (!markers[markerKey]) markers[markerKey] = {};
+        for (const [lang, markerText] of Object.entries(role.markerOverride)) {
+          markers[markerKey][lang] = markerText;
+        }
+      }
+    }
+  }
+  for (const profile of profiles2) {
+    if (profile.roleMarkers) {
+      for (const [markerKey, markerDef] of Object.entries(profile.roleMarkers)) {
+        if (!markers[markerKey]) markers[markerKey] = {};
+        markers[markerKey][profile.code] = markerDef.primary;
+      }
+    }
+  }
+  return { keywords, markers };
+}
+function detectWordOrders(profiles2) {
+  const sovLanguages = /* @__PURE__ */ new Set();
+  const vsoLanguages = /* @__PURE__ */ new Set();
+  for (const profile of profiles2) {
+    if (profile.wordOrder === "SOV") sovLanguages.add(profile.code);
+    if (profile.wordOrder === "VSO") vsoLanguages.add(profile.code);
+  }
+  return { sovLanguages, vsoLanguages };
+}
+function createSchemaRenderer(schemas, profiles2) {
+  const tables = buildRenderTables(schemas, profiles2);
+  return {
+    render(node, language) {
+      return renderFromSchema(node, language, tables) ?? node.action;
+    }
+  };
+}
+function createDomainRenderer(config2) {
+  const { schemas, profiles: profiles2, overrides } = config2;
+  let tables;
+  return (node, language) => {
+    const override = overrides?.[node.action];
+    if (override) return override(node, language);
+    tables ?? (tables = buildRenderTables(schemas, profiles2));
+    return renderFromSchema(node, language, tables);
+  };
+}
+function buildRenderTables(schemas, profiles2) {
+  const { keywords, markers } = buildTablesFromProfiles(schemas, profiles2);
+  const { sovLanguages } = detectWordOrders(profiles2);
+  const markerPositions = {};
+  for (const profile of profiles2) {
+    for (const [role, markerDef] of Object.entries(profile.roleMarkers ?? {})) {
+      if (!markerDef.position) continue;
+      markerPositions[role] ?? (markerPositions[role] = {});
+      markerPositions[role][profile.code] = markerDef.position;
+    }
+  }
+  const schemaMap = /* @__PURE__ */ new Map();
+  for (const s of schemas) schemaMap.set(s.action, s);
+  return { keywords, markers, markerPositions, sovLanguages, schemaMap };
+}
+function renderFromSchema(node, language, tables) {
+  const schema = tables.schemaMap.get(node.action);
+  if (!schema) return null;
+  const keyword = lookupKeyword(tables.keywords, node.action, language);
+  const isSOV = tables.sovLanguages.has(language);
+  const ordered = sortRolesByWordOrder$1([...schema.roles], isSOV ? "SOV" : "SVO");
+  const preVerb = [];
+  const postVerb = [];
+  for (const role of ordered) {
+    let value = extractRoleValue(node, role.role);
+    if (!value && role.default !== void 0) {
+      value = String(extractValue(role.default));
+    }
+    if (!value) continue;
+    if (role.quoteMultiword && /\s/.test(value) && !/^(["']).*\1$/.test(value)) {
+      value = `"${value}"`;
+    }
+    const markerText = role.renderOverride?.[language] ?? role.markerOverride?.[language] ?? role.renderOverride?.["*"] ?? tables.markers[role.role]?.[language];
+    const markerPosition = role.markerPositionOverride?.[language] ?? role.markerPosition ?? tables.markerPositions[role.role]?.[language] ?? (isSOV ? "after" : "before");
+    const bucket = isSOV && role.sovSlot === "postVerb" ? postVerb : preVerb;
+    if (markerText && markerPosition === "before") {
+      bucket.push(markerText, value);
+    } else if (markerText) {
+      bucket.push(value, markerText);
+    } else {
+      bucket.push(value);
+    }
+  }
+  return isSOV ? buildPhrase(...preVerb, keyword, ...postVerb) : buildPhrase(keyword, ...preVerb, ...postVerb);
+}
 function reorderRoles(roles, targetOrder) {
   const result = [];
   const usedRoles = /* @__PURE__ */ new Set();
@@ -29176,6 +29316,31 @@ var LatinExtendedIdentifierExtractor = class {
     return { value: input.slice(position, end), length: end - position };
   }
 };
+var SELECTOR_BODY_CHAR = /[\p{L}\p{N}_-]/u;
+var PARTICLE_SCRIPT_CHAR = /[\p{sc=Han}\p{sc=Hiragana}\p{sc=Katakana}\p{sc=Hangul}]/u;
+function isSelectorBodyChar(char) {
+  return SELECTOR_BODY_CHAR.test(char) && !PARTICLE_SCRIPT_CHAR.test(char);
+}
+var CssSelectorExtractor$1 = class CssSelectorExtractor {
+  constructor() {
+    this.name = "css-selector";
+  }
+  canExtract(input, position) {
+    const char = input[position];
+    if (char !== "#" && char !== ".") return false;
+    const next = input[position + 1];
+    if (next === void 0) return false;
+    return next === "_" || next === "-" || /\p{L}/u.test(next) && !PARTICLE_SCRIPT_CHAR.test(next);
+  }
+  extract(input, position) {
+    let end = position + 1;
+    while (end < input.length && isSelectorBodyChar(input[end])) {
+      end++;
+    }
+    if (end === position + 1) return null;
+    return { value: input.slice(position, end), length: end - position };
+  }
+};
 var WhitespaceExtractor = class {
   constructor() {
     this.name = "whitespace";
@@ -29895,10 +30060,17 @@ function semanticValueToAST(value) {
   }
 }
 var DSLRegistry = class {
-  constructor(config2) {
+  /**
+   * @param partiallyTranslatedActions Actions permitted to lack a keyword in
+   *   some configured languages — extension commands, which may be added for a
+   *   subset of the DSL's languages. A built-in command missing a keyword stays
+   *   an error, since that is a domain-authoring mistake.
+   */
+  constructor(config2, partiallyTranslatedActions = /* @__PURE__ */ new Set()) {
     this.patterns = /* @__PURE__ */ new Map();
     this.tokenizers = /* @__PURE__ */ new Map();
     this.schemas = config2.schemas;
+    this.partiallyTranslatedActions = partiallyTranslatedActions;
     for (const lang of config2.languages) {
       this.registerLanguage(lang);
     }
@@ -29907,6 +30079,9 @@ var DSLRegistry = class {
     this.tokenizers.set(lang.code, lang.tokenizer);
     const patterns = [];
     for (const schema of this.schemas) {
+      if (this.partiallyTranslatedActions.has(schema.action) && !lang.patternProfile.keywords[schema.action]) {
+        continue;
+      }
       const pattern = generatePattern$1(schema, lang.patternProfile);
       patterns.push(pattern);
     }
@@ -29923,13 +30098,25 @@ var DSLRegistry = class {
   }
 };
 var MultilingualDSLImpl = class {
-  constructor(config2, registry, transformer) {
+  constructor(config2, registry, transformer, profileProvider) {
     this.registry = registry;
     this.matcher = new PatternMatcher$1();
     this.transformer = transformer;
+    this.profileProvider = profileProvider;
     if (config2.codeGenerator) {
       this.codeGenerator = config2.codeGenerator;
     }
+    if (config2.renderer) {
+      this.domainRenderer = config2.renderer;
+    }
+    this.extensionRenderers = /* @__PURE__ */ new Map();
+    for (const extension of config2.extensions ?? []) {
+      if (extension.render) this.extensionRenderers.set(extension.schema.action, extension.render);
+    }
+    this.schemaFallbackRenderer = createDomainRenderer({
+      schemas: config2.schemas,
+      profiles: config2.languages.map((l) => l.patternProfile)
+    });
     const schemaMap = new Map(config2.schemas.map((s) => [s.action, s]));
     this.schemaLookup = {
       getSchema: (action) => schemaMap.get(action)
@@ -29991,6 +30178,13 @@ var MultilingualDSLImpl = class {
   }
   translate(input, fromLanguage, toLanguage) {
     if (isExplicitSyntax$1(input)) return input;
+    for (const language of [fromLanguage, toLanguage]) {
+      if (!this.profileProvider.getProfile(language)) {
+        throw new Error(
+          `translate() requires a grammar profile for language "${language}", but none is configured. Set 'grammarProfile' on the LanguageConfig for "${language}" in createMultilingualDSL() (parse/validate/compile do not need it), or inject a custom 'profileProvider'.`
+        );
+      }
+    }
     return this.transformer.transform(input, fromLanguage, toLanguage);
   }
   compile(input, language) {
@@ -30019,6 +30213,18 @@ var MultilingualDSLImpl = class {
       };
     }
   }
+  render(node, language) {
+    const extensionRenderer = this.extensionRenderers.get(node.action);
+    if (extensionRenderer) {
+      const rendered = extensionRenderer(node, language);
+      if (rendered != null) return rendered;
+    }
+    if (this.domainRenderer) {
+      const rendered = this.domainRenderer(node, language);
+      if (rendered != null) return rendered;
+    }
+    return this.schemaFallbackRenderer(node, language);
+  }
   getSupportedLanguages() {
     return this.registry.getSupportedLanguages();
   }
@@ -30043,15 +30249,80 @@ function createDefaultProfileProvider(config2) {
   }
   return new InMemoryProfileProvider(profiles2);
 }
+function applyExtensions(config2) {
+  const extensions = config2.extensions;
+  if (!extensions || extensions.length === 0) return config2;
+  const configuredLanguages = new Set(config2.languages.map((l) => l.code));
+  const actions = new Set(config2.schemas.map((s) => s.action));
+  for (const extension of extensions) {
+    const { action } = extension.schema;
+    if (actions.has(action)) {
+      throw new Error(
+        `Extension command "${action}" collides with a command this DSL already defines. Pick a different action name.`
+      );
+    }
+    actions.add(action);
+    for (const code of Object.keys(extension.vocabulary)) {
+      if (!configuredLanguages.has(code)) {
+        throw new Error(
+          `Extension command "${action}" supplies vocabulary for language "${code}", which is not configured on this DSL. Configured languages: ${[...configuredLanguages].join(", ")}.`
+        );
+      }
+    }
+  }
+  const schemas = [...config2.schemas, ...extensions.map((e) => e.schema)];
+  const languages = config2.languages.map((lang) => {
+    const keywords = { ...lang.patternProfile.keywords };
+    let roleMarkers = lang.patternProfile.roleMarkers;
+    for (const extension of extensions) {
+      const vocabulary = extension.vocabulary[lang.code];
+      if (!vocabulary) continue;
+      keywords[extension.schema.action] = { ...vocabulary.keyword };
+      if (vocabulary.roleMarkers) {
+        roleMarkers = { ...roleMarkers, ...vocabulary.roleMarkers };
+      }
+    }
+    return {
+      ...lang,
+      patternProfile: {
+        ...lang.patternProfile,
+        keywords,
+        ...roleMarkers !== void 0 && { roleMarkers }
+      }
+    };
+  });
+  const extensionGenerators = new Map(
+    extensions.filter((e) => e.generate).map((e) => [e.schema.action, e.generate])
+  );
+  const baseGenerator = config2.codeGenerator;
+  const codeGenerator = extensionGenerators.size > 0 ? {
+    generate(node) {
+      const generate = extensionGenerators.get(node.action);
+      if (generate) return generate(node);
+      if (!baseGenerator) {
+        throw new Error(`No code generator for action "${node.action}"`);
+      }
+      return baseGenerator.generate(node);
+    }
+  } : baseGenerator;
+  return {
+    ...config2,
+    schemas,
+    languages,
+    ...codeGenerator !== void 0 && { codeGenerator }
+  };
+}
 function createMultilingualDSL(config2) {
-  const dictionary = config2.dictionary ?? createDefaultDictionary(config2);
-  const profileProvider = config2.profileProvider ?? createDefaultProfileProvider(config2);
+  const effectiveConfig = applyExtensions(config2);
+  const extensionActions = new Set((config2.extensions ?? []).map((e) => e.schema.action));
+  const dictionary = effectiveConfig.dictionary ?? createDefaultDictionary(effectiveConfig);
+  const profileProvider = effectiveConfig.profileProvider ?? createDefaultProfileProvider(effectiveConfig);
   const transformer = new GrammarTransformer({
     dictionary,
     profileProvider
   });
-  const registry = new DSLRegistry(config2);
-  return new MultilingualDSLImpl(config2, registry, transformer);
+  const registry = new DSLRegistry(effectiveConfig, extensionActions);
+  return new MultilingualDSLImpl(effectiveConfig, registry, transformer, profileProvider);
 }
 function generatePrompt(config2) {
   const outputFormat = config2.outputFormat ?? "both";
@@ -31014,6 +31285,11 @@ var DomainRegistry = class {
         rendered = typeof renderer === "function" ? renderer(node, to) : renderer.render(node, to);
       } catch {
       }
+    } else if (dsl.render) {
+      try {
+        rendered = dsl.render(node, to);
+      } catch {
+      }
     }
     const roles = {};
     for (const [key, value] of node.roles) {
@@ -31559,94 +31835,6 @@ async function registryToAOTBackends(registry) {
   }
   return backends;
 }
-function lookupKeyword(keywords, action, language) {
-  return keywords[action]?.[language] ?? action;
-}
-function lookupMarker(markers, marker, language) {
-  return markers[marker]?.[language] ?? marker;
-}
-function buildPhrase(...parts) {
-  return parts.filter(Boolean).join(" ");
-}
-function buildTablesFromProfiles(schemas, profiles2) {
-  const keywords = {};
-  const markers = {};
-  for (const profile of profiles2) {
-    for (const [action, kw] of Object.entries(profile.keywords)) {
-      if (!keywords[action]) keywords[action] = {};
-      keywords[action][profile.code] = kw.primary;
-    }
-  }
-  for (const schema of schemas) {
-    for (const role of schema.roles) {
-      if (role.markerOverride) {
-        const markerKey = role.role;
-        if (!markers[markerKey]) markers[markerKey] = {};
-        for (const [lang, markerText] of Object.entries(role.markerOverride)) {
-          markers[markerKey][lang] = markerText;
-        }
-      }
-    }
-  }
-  for (const profile of profiles2) {
-    if (profile.roleMarkers) {
-      for (const [markerKey, markerDef] of Object.entries(profile.roleMarkers)) {
-        if (!markers[markerKey]) markers[markerKey] = {};
-        markers[markerKey][profile.code] = markerDef.primary;
-      }
-    }
-  }
-  return { keywords, markers };
-}
-function detectWordOrders(profiles2) {
-  const sovLanguages = /* @__PURE__ */ new Set();
-  const vsoLanguages = /* @__PURE__ */ new Set();
-  for (const profile of profiles2) {
-    if (profile.wordOrder === "SOV") sovLanguages.add(profile.code);
-    if (profile.wordOrder === "VSO") vsoLanguages.add(profile.code);
-  }
-  return { sovLanguages, vsoLanguages };
-}
-function createSchemaRenderer(schemas, profiles2) {
-  const { keywords, markers } = buildTablesFromProfiles(schemas, profiles2);
-  const { sovLanguages } = detectWordOrders(profiles2);
-  const schemaMap = /* @__PURE__ */ new Map();
-  for (const s of schemas) schemaMap.set(s.action, s);
-  return {
-    render(node, language) {
-      const schema = schemaMap.get(node.action);
-      if (!schema) return node.action;
-      const keyword = lookupKeyword(keywords, node.action, language);
-      const isSOV = sovLanguages.has(language);
-      const roleParts = [];
-      for (const role of schema.roles) {
-        const value = extractRoleValue(node, role.role);
-        if (!value && !role.required) continue;
-        const markerText = role.markerOverride?.[language] ?? markers[role.role]?.[language] ?? void 0;
-        roleParts.push({
-          ...markerText != null && { marker: markerText },
-          value: value || "",
-          role
-        });
-      }
-      const parts = [];
-      if (isSOV) {
-        for (const rp of roleParts) {
-          if (rp.value) parts.push(rp.value);
-          if (rp.marker) parts.push(rp.marker);
-        }
-        parts.push(keyword);
-      } else {
-        parts.push(keyword);
-        for (const rp of roleParts) {
-          if (rp.marker) parts.push(rp.marker);
-          if (rp.value) parts.push(rp.value);
-        }
-      }
-      return buildPhrase(...parts);
-    }
-  };
-}
 var TokenStreamImpl = class {
   constructor(tokens, language) {
     this.pos = 0;
@@ -31752,6 +31940,9 @@ function isQuote(char) {
 function isDigit(char) {
   return /\d/.test(char);
 }
+function stripOptionalDiacritics(word) {
+  return word.replace(/[ً-ْٰ]/g, "");
+}
 function isAsciiLetter(char) {
   return /[a-zA-Z]/.test(char);
 }
@@ -32457,7 +32648,7 @@ var _BaseTokenizer = class _BaseTokenizer2 {
    * @returns Word without diacritics
    */
   removeDiacritics(word) {
-    return word.replace(/[\u064B-\u0652\u0670]/g, "");
+    return stripOptionalDiacritics(word);
   }
   /**
    * Try to match a keyword from profile at the current position.
@@ -32548,24 +32739,40 @@ var _BaseTokenizer = class _BaseTokenizer2 {
     });
   }
   /**
-   * Look up a keyword by native word (case-insensitive).
+   * Look up a keyword by native word (case-insensitive, diacritic-insensitive).
    * O(1) lookup using the keyword map.
    *
+   * The map is INDEXED both with and without diacritics (see
+   * `initializeKeywordsFromProfile`), so a stripped QUERY is the other half of
+   * that: it lets a surface form carrying harakat the profile does not happen to
+   * spell still find its entry. Only consulted after the exact lookup misses, so
+   * every previously-matching word resolves byte-identically.
+   *
+   * Half-implementing this — indexing stripped but querying exact — is what made
+   * diacritized `بَدِّل` (toggle) tokenize as `kind=particle normalized=with`:
+   * `isKeyword` returned false, so the guard in `ArabicProcliticExtractor` that
+   * exists to prevent exactly that handed the word on, and the single-char `ب`
+   * bi- proclitic claimed it. A wrong CONCEPT, not a failed parse.
+   *
    * @param native - Native word to look up
    * @returns KeywordEntry if found, undefined otherwise
    */
   lookupKeyword(native) {
-    return this.profileKeywordMap.get(native.toLowerCase());
+    const exact = this.profileKeywordMap.get(native.toLowerCase());
+    if (exact) return exact;
+    const stripped = this.removeDiacritics(native);
+    if (stripped === native) return void 0;
+    return this.profileKeywordMap.get(stripped.toLowerCase());
   }
   /**
-   * Check if a word is a known keyword (case-insensitive).
-   * O(1) lookup using the keyword map.
+   * Check if a word is a known keyword (case-insensitive, diacritic-insensitive).
+   * O(1) lookup using the keyword map. See {@link lookupKeyword}.
    *
    * @param native - Native word to check
    * @returns true if the word is a keyword
    */
   isKeyword(native) {
-    return this.profileKeywordMap.has(native.toLowerCase());
+    return this.lookupKeyword(native) !== void 0;
   }
   /**
    * Set the morphological normalizer for this tokenizer.
@@ -33517,6 +33724,7 @@ var index$2 = /* @__PURE__ */ Object.freeze({
   BaseMorphologicalNormalizer,
   BaseTokenizer,
   CrossDomainDispatcher,
+  CssSelectorExtractor: CssSelectorExtractor$1,
   DEFAULT_OPERATORS: DEFAULT_OPERATORS$1,
   DEFAULT_PUNCTUATION: DEFAULT_PUNCTUATION$1,
   DEFAULT_REFERENCES,
@@ -33553,6 +33761,7 @@ var index$2 = /* @__PURE__ */ Object.freeze({
   createCompoundNode: createCompoundNode$1,
   createConditionalNode: createConditionalNode$1,
   createDiagnosticCollector,
+  createDomainRenderer,
   createEventHandlerNode,
   createExpression,
   createFlag,
@@ -33644,6 +33853,8 @@ var index$2 = /* @__PURE__ */ Object.freeze({
   semanticNodeToJSON,
   semanticNodeToRuntimeAST: semanticNodeToRuntimeAST$1,
   semanticValueToAST,
+  sortRolesByWordOrder: sortRolesByWordOrder$1,
+  stripOptionalDiacritics,
   synthesizeFromSchemas,
   toEnvelopeJSON: toEnvelopeJSON$1,
   toJSONL,
@@ -34005,9 +34216,12 @@ var init_arabic = __esm({
         behavior: { primary: "\u0633\u0644\u0648\u0643", normalized: "behavior" },
         install: { primary: "\u062A\u062B\u0628\u064A\u062A", alternatives: ["\u062B\u0628\u0651\u062A"], normalized: "install" },
         // `قِس` is the imperative with the kasra diacritic; the i18n dict (and real
-        // Arabic prose) emits it undiacritized as `قس`, so list both — otherwise the
-        // generated `قس width`/`قس x` (behavior-draggable/resizable) parse to null and
-        // the whole `measure` command drops from the event-handler body (lossy).
+        // Arabic prose) emits it undiacritized as `قس`. BOTH stay listed, and not
+        // for the tokenizer's sake — keyword lookup is diacritic-insensitive now, so
+        // either spelling resolves. It is the vocab gate's V1 check, which compares
+        // the profile against the i18n DICTIONARY as strings: the dictionary says
+        // `قس`, so dropping it here fails V1 (verified). Diacritic-insensitivity
+        // would have to reach that comparison too before this pair can collapse.
         measure: { primary: "\u0642\u064A\u0627\u0633", alternatives: ["\u0642\u0650\u0633", "\u0642\u0633"], normalized: "measure" },
         beep: { primary: "\u0635\u0641\u0651\u0631", normalized: "beep" },
         break: { primary: "\u062A\u0648\u0642\u0641", normalized: "break" },
@@ -34683,6 +34897,15 @@ var init_spanish = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "con", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         // Class/Attribute operations
         toggle: { primary: "alternar", alternatives: ["conmutar", "toggle"], normalized: "toggle" },
@@ -34702,19 +34925,23 @@ var init_spanish = __esm({
         swap: { primary: "intercambiar", alternatives: ["permutar"], normalized: "swap" },
         morph: { primary: "transformar", alternatives: ["convertir"], normalized: "morph" },
         // Variable operations
-        set: { primary: "establecer", alternatives: ["fijar", "definir"], normalized: "set" },
-        get: { primary: "obtener", alternatives: ["conseguir"], normalized: "get" },
+        set: {
+          primary: "establecer",
+          alternatives: ["fijar", "definir", "establece"],
+          normalized: "set"
+        },
+        get: { primary: "obtener", alternatives: ["conseguir", "obt\xE9n"], normalized: "get" },
         increment: { primary: "incrementar", alternatives: ["aumentar"], normalized: "increment" },
         decrement: { primary: "decrementar", alternatives: ["disminuir"], normalized: "decrement" },
         log: { primary: "registrar", alternatives: ["imprimir"], normalized: "log" },
         // Visibility
-        show: { primary: "mostrar", alternatives: ["ense\xF1ar"], normalized: "show" },
+        show: { primary: "mostrar", alternatives: ["ense\xF1ar", "muestra"], normalized: "show" },
         hide: { primary: "ocultar", alternatives: ["esconder"], normalized: "hide" },
         transition: { primary: "transici\xF3n", alternatives: ["animar"], normalized: "transition" },
         // Events
         on: { primary: "en", alternatives: ["al"], normalized: "on" },
         trigger: { primary: "disparar", alternatives: ["activar"], normalized: "trigger" },
-        send: { primary: "enviar", normalized: "send" },
+        send: { primary: "enviar", alternatives: ["env\xEDa"], normalized: "send" },
         // DOM focus
         focus: { primary: "enfocar", alternatives: ["enfoque"], normalized: "focus" },
         blur: { primary: "desenfocar", alternatives: ["desenfoque"], normalized: "blur" },
@@ -34751,7 +34978,7 @@ var init_spanish = __esm({
         mousedown: { primary: "rat\xF3nabajo", normalized: "mousedown" },
         mouseup: { primary: "rat\xF3narriba", normalized: "mouseup" },
         // Navigation
-        go: { primary: "ir", alternatives: ["navegar"], normalized: "go" },
+        go: { primary: "ir", alternatives: ["navegar", "ve"], normalized: "go" },
         push: { primary: "empujar", alternatives: ["push"], normalized: "push" },
         replace: { primary: "reemplazar", alternatives: ["sustituir"], normalized: "replace" },
         process: { primary: "procesar", normalized: "process" },
@@ -34938,11 +35165,24 @@ var init_french = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "avec", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         toggle: { primary: "basculer", alternatives: ["alterner"], normalized: "toggle" },
         add: { primary: "ajouter", normalized: "add" },
-        remove: { primary: "supprimer", alternatives: ["enlever", "retirer"], normalized: "remove" },
-        put: { primary: "mettre", alternatives: ["placer"], normalized: "put" },
+        remove: {
+          primary: "supprimer",
+          alternatives: ["enlever", "retirer", "retire"],
+          normalized: "remove"
+        },
+        put: { primary: "mettre", alternatives: ["placer", "mets"], normalized: "put" },
         append: { primary: "annexer", normalized: "append" },
         prepend: { primary: "pr\xE9fixer", normalized: "prepend" },
         take: { primary: "prendre", normalized: "take" },
@@ -34951,16 +35191,16 @@ var init_french = __esm({
         swap: { primary: "\xE9changer", alternatives: ["permuter"], normalized: "swap" },
         morph: { primary: "transformer", alternatives: ["m\xE9tamorphoser"], normalized: "morph" },
         set: { primary: "d\xE9finir", alternatives: ["\xE9tablir"], normalized: "set" },
-        get: { primary: "obtenir", normalized: "get" },
+        get: { primary: "obtenir", alternatives: ["obtiens"], normalized: "get" },
         increment: { primary: "incr\xE9menter", alternatives: ["augmenter"], normalized: "increment" },
         decrement: { primary: "d\xE9cr\xE9menter", alternatives: ["diminuer"], normalized: "decrement" },
         log: { primary: "enregistrer", alternatives: ["journaliser"], normalized: "log" },
-        show: { primary: "montrer", alternatives: ["afficher"], normalized: "show" },
+        show: { primary: "montrer", alternatives: ["afficher", "montre"], normalized: "show" },
         hide: { primary: "cacher", alternatives: ["masquer"], normalized: "hide" },
         transition: { primary: "transition", alternatives: ["animer"], normalized: "transition" },
         on: { primary: "sur", alternatives: ["lors"], normalized: "on" },
         trigger: { primary: "d\xE9clencher", normalized: "trigger" },
-        send: { primary: "envoyer", normalized: "send" },
+        send: { primary: "envoyer", alternatives: ["envoie"], normalized: "send" },
         focus: { primary: "focaliser", alternatives: ["concentrer"], normalized: "focus" },
         blur: { primary: "d\xE9focaliser", normalized: "blur" },
         // Phase 1 (v0.9.90): DOM / form state / debug
@@ -34974,13 +35214,13 @@ var init_french = __esm({
         clear: { primary: "effacer", normalized: "clear" },
         reset: { primary: "r\xE9initialiser", alternatives: ["reinitialiser"], normalized: "reset" },
         breakpoint: { primary: "point-arr\xEAt", alternatives: ["point-arret"], normalized: "breakpoint" },
-        go: { primary: "aller", alternatives: ["naviguer"], normalized: "go" },
+        go: { primary: "aller", alternatives: ["naviguer", "va"], normalized: "go" },
         scroll: { primary: "d\xE9filer", alternatives: ["faire-d\xE9filer"], normalized: "scroll" },
         push: { primary: "pousser", normalized: "push" },
         replace: { primary: "remplacer", normalized: "replace" },
         process: { primary: "traiter", normalized: "process" },
         wait: { primary: "attendre", normalized: "wait" },
-        fetch: { primary: "chercher", alternatives: ["r\xE9cup\xE9rer"], normalized: "fetch" },
+        fetch: { primary: "chercher", alternatives: ["r\xE9cup\xE9rer", "r\xE9cup\xE8re"], normalized: "fetch" },
         settle: { primary: "stabiliser", normalized: "settle" },
         if: { primary: "si", normalized: "if" },
         unless: { primary: "saufsi", normalized: "unless" },
@@ -36339,16 +36579,25 @@ var init_korean = __esm({
         event: { primary: "\uC744", alternatives: ["\uB97C"], position: "after" }
         // Event as object marker
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         // Class/Attribute operations
         toggle: { primary: "\uD1A0\uAE00", normalized: "toggle" },
         add: { primary: "\uCD94\uAC00", normalized: "add" },
         remove: { primary: "\uC81C\uAC70", alternatives: ["\uC0AD\uC81C"], normalized: "remove" },
         // Content operations
-        put: { primary: "\uB123\uB2E4", alternatives: ["\uB123\uAE30", "\uB193\uAE30"], normalized: "put" },
+        put: { primary: "\uB123\uB2E4", alternatives: ["\uB123\uAE30", "\uB193\uAE30", "\uB123\uC73C\uC138\uC694"], normalized: "put" },
         append: { primary: "\uB367\uBD99\uC774\uB2E4", alternatives: ["\uB05D\uC5D0\uCD94\uAC00"], normalized: "append" },
         prepend: { primary: "\uC55E\uC5D0\uCD94\uAC00", alternatives: ["\uC120\uB450\uCD94\uAC00"], normalized: "prepend" },
-        take: { primary: "\uAC00\uC838\uC624\uB2E4", normalized: "take" },
+        take: { primary: "\uAC00\uC838\uC624\uB2E4", alternatives: ["\uAC00\uC838\uC624\uC138\uC694"], normalized: "take" },
         make: { primary: "\uB9CC\uB4E4\uB2E4", normalized: "make" },
         clone: { primary: "\uBCF5\uC81C", normalized: "clone" },
         // 복제=duplicate/clone, 복사=copy
@@ -36356,13 +36605,13 @@ var init_korean = __esm({
         morph: { primary: "\uBCC0\uD615", alternatives: ["\uBCC0\uD658"], normalized: "morph" },
         // Variable operations
         set: { primary: "\uC124\uC815", normalized: "set" },
-        get: { primary: "\uC5BB\uB2E4", normalized: "get" },
+        get: { primary: "\uC5BB\uB2E4", alternatives: ["\uC5BB\uC73C\uC138\uC694"], normalized: "get" },
         increment: { primary: "\uC99D\uAC00", normalized: "increment" },
         decrement: { primary: "\uAC10\uC18C", normalized: "decrement" },
         log: { primary: "\uB85C\uADF8", normalized: "log" },
         // Visibility
-        show: { primary: "\uBCF4\uC774\uB2E4", alternatives: ["\uD45C\uC2DC", "\uBCF4\uC774\uAE30"], normalized: "show" },
-        hide: { primary: "\uC228\uAE30\uB2E4", alternatives: ["\uC228\uAE30\uAE30"], normalized: "hide" },
+        show: { primary: "\uBCF4\uC774\uB2E4", alternatives: ["\uD45C\uC2DC", "\uBCF4\uC774\uAE30", "\uBCF4\uC774\uC138\uC694"], normalized: "show" },
+        hide: { primary: "\uC228\uAE30\uB2E4", alternatives: ["\uC228\uAE30\uAE30", "\uC228\uAE30\uC138\uC694"], normalized: "hide" },
         // primary is the loanword 트랜지션; 전환 ("switch/transition") is the form the
         // i18n transformer emits — registered as an alternative (passthrough-alignment).
         // toggle uses 토글, so 전환 carries no collision.
@@ -36370,7 +36619,7 @@ var init_korean = __esm({
         // Events
         on: { primary: "\uC5D0", alternatives: ["\uC2DC", "\uD560 \uB54C"], normalized: "on" },
         trigger: { primary: "\uD2B8\uB9AC\uAC70", normalized: "trigger" },
-        send: { primary: "\uBCF4\uB0B4\uB2E4", normalized: "send" },
+        send: { primary: "\uBCF4\uB0B4\uB2E4", alternatives: ["\uBCF4\uB0B4\uC138\uC694"], normalized: "send" },
         // DOM focus
         focus: { primary: "\uD3EC\uCEE4\uC2A4", normalized: "focus" },
         blur: { primary: "\uBE14\uB7EC", normalized: "blur" },
@@ -37146,25 +37395,38 @@ var init_portuguese = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "com", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         toggle: { primary: "alternar", alternatives: [], normalized: "toggle" },
         add: { primary: "adicionar", alternatives: ["acrescentar"], normalized: "add" },
-        remove: { primary: "remover", alternatives: ["eliminar", "apagar"], normalized: "remove" },
-        put: { primary: "colocar", alternatives: ["p\xF4r", "por"], normalized: "put" },
+        remove: {
+          primary: "remover",
+          alternatives: ["eliminar", "apagar", "remova"],
+          normalized: "remove"
+        },
+        put: { primary: "colocar", alternatives: ["p\xF4r", "por", "coloque"], normalized: "put" },
         append: { primary: "anexar", normalized: "append" },
         prepend: { primary: "preceder", normalized: "prepend" },
-        take: { primary: "pegar", normalized: "take" },
+        take: { primary: "pegar", alternatives: ["pegue"], normalized: "take" },
         make: { primary: "fazer", alternatives: ["criar"], normalized: "make" },
         clone: { primary: "clonar", alternatives: [], normalized: "clone" },
         swap: { primary: "trocar", alternatives: ["substituir"], normalized: "swap" },
         morph: { primary: "transformar", alternatives: ["converter"], normalized: "morph" },
-        set: { primary: "definir", alternatives: ["configurar"], normalized: "set" },
-        get: { primary: "obter", normalized: "get" },
+        set: { primary: "definir", alternatives: ["configurar", "defina"], normalized: "set" },
+        get: { primary: "obter", alternatives: ["obtenha"], normalized: "get" },
         increment: { primary: "incrementar", alternatives: ["aumentar"], normalized: "increment" },
         decrement: { primary: "decrementar", alternatives: ["diminuir"], normalized: "decrement" },
         log: { primary: "registrar", alternatives: ["imprimir"], normalized: "log" },
         show: { primary: "mostrar", alternatives: ["exibir"], normalized: "show" },
-        hide: { primary: "ocultar", alternatives: ["esconder"], normalized: "hide" },
+        hide: { primary: "ocultar", alternatives: ["esconder", "esconda"], normalized: "hide" },
         transition: { primary: "transi\xE7\xE3o", alternatives: ["animar"], normalized: "transition" },
         on: { primary: "em", alternatives: ["ao"], normalized: "on" },
         trigger: { primary: "disparar", alternatives: ["ativar"], normalized: "trigger" },
@@ -37183,13 +37445,13 @@ var init_portuguese = __esm({
           alternatives: ["ponto-interrupcao"],
           normalized: "breakpoint"
         },
-        go: { primary: "ir", alternatives: ["navegar"], normalized: "go" },
+        go: { primary: "ir", alternatives: ["navegar", "v\xE1"], normalized: "go" },
         scroll: { primary: "rolar", alternatives: ["scroll"], normalized: "scroll" },
         push: { primary: "empurrar", alternatives: ["push"], normalized: "push" },
         replace: { primary: "repor", alternatives: ["recolocar"], normalized: "replace" },
         process: { primary: "processar", normalized: "process" },
         wait: { primary: "esperar", alternatives: ["aguardar"], normalized: "wait" },
-        fetch: { primary: "buscar", normalized: "fetch" },
+        fetch: { primary: "buscar", alternatives: ["busque"], normalized: "fetch" },
         settle: { primary: "estabilizar", normalized: "settle" },
         if: { primary: "se", normalized: "if" },
         // salvo — single token ('salvo se' = unless). a_menos kept as an
@@ -40314,8 +40576,53 @@ var init_command_schemas = __esm({
           default: { type: "reference", value: "me" },
           svoPosition: 2,
           sovPosition: 1,
-          markerOverride: { en: "to" }
-          // "add .class to #element"
+          // `add` is directional, but every profile's `destination` marker is
+          // LOCATIVE (en on, es en, ar على, zh 在, fr sur, de auf, pt em) because
+          // it also serves `toggle`/`show`. Without a per-language override the
+          // rendered text said "add .class ON #element" in every language but
+          // English — the gap lokascript-learn corrects with 6 of its 16 override
+          // entries. ja に / ko 에 / tr e are already directional, so they keep
+          // the profile default.
+          //
+          // Tier B (2.9): he/id/it/sw were the remaining locatives that this
+          // language actually distinguishes.
+          //   he — `על` is "ON"; Hebrew adds with the allative `אל` (`ל` is a bound
+          //        prefix, so it cannot stand as a separate marker token).
+          //   id — `pada` is "at/on"; `ke` is the directional, and it is what the
+          //        i18n corpus already renders for every id destination.
+          //   it — `in` is locative; Italian adds with `a` (`aggiungere a`).
+          //   sw — `kwenye` is not merely locative, it is sw's EVENT keyword
+          //        (`on: 'kwenye'` in the dictionary), so reusing it as a
+          //        destination marker collides. `kwa` is the corpus rendering.
+          // hi `में` / ru+uk `в` / th `ใน` / vi `vào` are already the right
+          // container-directional for "add to", and keep the profile default.
+          markerOverride: {
+            en: "to",
+            es: "a",
+            ar: "\u0625\u0644\u0649",
+            zh: "\u5230",
+            fr: "\xE0",
+            de: "zu",
+            pt: "a",
+            he: "\u05D0\u05DC",
+            id: "ke",
+            it: "a",
+            sw: "kwa"
+          },
+          // Each language's previous primary marker (and its alternates) still
+          // parses, so source written against ≤2.8 keeps working.
+          markerLegacy: {
+            es: ["en", "sobre", "hacia"],
+            ar: ["\u0639\u0644\u0649", "\u0641\u064A", "\u0628"],
+            zh: ["\u5728", "\u4E8E"],
+            fr: ["sur", "dans"],
+            de: ["auf", "in"],
+            pt: ["em", "para"],
+            he: ["\u05E2\u05DC", "\u05D1", "\u05DC"],
+            id: ["pada", "di"],
+            it: ["in", "su"],
+            sw: ["kwenye"]
+          }
         }
       ],
       // Runtime error documentation
@@ -40405,12 +40712,39 @@ var init_command_schemas = __esm({
           svoPosition: 2,
           sovPosition: 2,
           // SOV: destination comes second (に/에/a marker)
-          markerOverride: { en: "into" },
-          // "put 'hello' into #output"
+          // "put 'hello' into #output" — directional, so the same locative-default
+          // correction as `add`. es `en` and pt `em` are already right for "into",
+          // as are ja に / ko 에 / tr e; only ar/zh/fr/de need an override.
+          //
+          // Tier B (2.9): `put` is ILLATIVE, so it diverges from `add` where the
+          // two senses differ. he takes `ב` ("in/into" — `שים ב`), NOT the allative
+          // `אל` that `add`/`go` take. it keeps its locative `in` (`mettere in`) —
+          // it is `add`/`go` that needed `a`. id/sw change for the same reason as
+          // `add` (directional / event-keyword collision). hi `में`, ru+uk `в`,
+          // th `ใน` and vi `vào` are all already the illative.
+          markerOverride: {
+            en: "into",
+            ar: "\u0641\u064A",
+            zh: "\u5230",
+            fr: "dans",
+            de: "in",
+            he: "\u05D1",
+            id: "ke",
+            sw: "kwa"
+          },
           // `before` / `after` are alternate position markers; the matched marker
           // is recorded as a literal in the `method` role (a derived role with no
           // surface form of its own — populated by schema-driven role inference).
           markerVariants: { en: ["before", "after"] },
+          markerLegacy: {
+            ar: ["\u0639\u0644\u0649", "\u0625\u0644\u0649", "\u0628"],
+            zh: ["\u5728", "\u4E8E"],
+            fr: ["sur", "\xE0"],
+            de: ["auf", "zu"],
+            he: ["\u05E2\u05DC", "\u05D0\u05DC", "\u05DC"],
+            id: ["pada", "di"],
+            sw: ["kwenye"]
+          },
           methodCarrier: "method"
         }
       ],
@@ -40545,8 +40879,11 @@ var init_command_schemas = __esm({
           // ending in a vowel (`doğru ya` = "true" in set-attribute). markerOverride
           // is a single string, so the generated tr set patterns carried only `e`
           // and set-attribute fell to the role-scrambling generic SOV extraction.
-          // markerVariants supplies the allomorphs the SOV two-role generators merge
-          // in as marker alternatives. See STRUCTURAL_ARCS_ROADMAP.md (tr set-attribute).
+          // markerVariants supplies the allomorphs, merged in as marker alternatives.
+          // Until 2026-07-25 only the SOV two-role generators merged them, so this
+          // worked ONLY inside an event handler: `@disabled i doğru ya ayarla` did
+          // not parse as a bare command while `tıklama da @disabled i doğru ya
+          // ayarla` did. See STRUCTURAL_ARCS_ROADMAP.md (tr set-attribute).
           markerVariants: {
             tr: ["e", "a", "ye", "ya"]
           }
@@ -41478,17 +41815,100 @@ var init_command_schemas = __esm({
           expectedTypes: ["literal", "expression"],
           svoPosition: 1,
           sovPosition: 1,
-          markerOverride: { en: "to" },
-          // "go to /page" (parsing)
-          renderOverride: { en: "" },
-          // "go /page" (rendering — no preposition)
+          // "go to /page" (parsing). Directional, so the same locative-default
+          // correction as `add`/`put`.
+          //
+          // Tier B (2.9): `go` is pure ALLATIVE — motion toward a target — so it
+          // needs the directional in more languages than `add`/`put` do, including
+          // ones where a container-locative was fine for those two.
+          //   he — `אל` ("toward"), as `add`; `לך על url` read "go ON url".
+          //   hi — `पर`: Hindi navigates to a page with `पर जाएं`; `में` is
+          //        "go INTO", which is entering a place, not opening a URL.
+          //   id — `ke`, as `add`.
+          //   it — `a`: `andare a` for a specific target (`andare in` is for
+          //        regions — `andare in Italia`).
+          //   ru/uk — `на`: `перейти на сторінку` is the navigation idiom; `в`
+          //        ("into") is right for `add`/`put` but not for opening a page.
+          //   sw — `kwa`, as `add`.
+          // th is NOT here — it renders bare, with zh and vi; see below.
+          markerOverride: {
+            en: "to",
+            es: "a",
+            ar: "\u0625\u0644\u0649",
+            fr: "\xE0",
+            de: "zu",
+            pt: "para",
+            he: "\u05D0\u05DC",
+            hi: "\u092A\u0930",
+            id: "ke",
+            it: "a",
+            ru: "\u043D\u0430",
+            sw: "kwa",
+            uk: "\u043D\u0430"
+          },
+          // "go /page" (rendering — no preposition).
+          //
+          // zh, vi and th render BARE.
+          //
+          // zh and vi because their `go` keyword already encodes the direction, so
+          // any destination marker is a second one: zh `前往` is "proceed-to"
+          // (`前往 到 url` = "proceed-to to url") and vi `đi đến` is literally
+          // "go to" (`đi đến vào url` = "go-to into url"). Both are corrected in
+          // the i18n corpus in the same change
+          // (`patterns-reference/scripts/fix-translations.sql`).
+          //
+          // th because Thai motion verbs take a BARE destination — `ไปบ้าน`
+          // ("go home"), `ไปโรงเรียน` ("go school") — so `ไป url` is the idiomatic
+          // form. The profile default rendered `ไป ใน url` ("go IN url"), which is
+          // what needed fixing; the obvious replacement `ยัง` (giving the formal
+          // `ไปยัง`) is rejected because `ยัง` is also the very common adverb
+          // "still/yet", and the V4 vocab gate correctly refuses to classify it as
+          // a particle — promoting it would mis-tokenize ordinary Thai.
+          //
+          // Parsing is unaffected for all three: none has a `markerOverride`, so
+          // each stays on the profile-default branch and keeps accepting its old
+          // markers (th `ใน` / `ไปยัง`) from the profile itself.
+          renderOverride: { en: "", zh: "", vi: "", th: "" },
           // `go back` renders the destination bare in en (history nav has no `to`),
           // and he/zh render it with their PATIENT marker (לך את back / 前往 把 back)
           // while go-url keeps the destination marker (לך על url / 前往 到 url) —
           // the corpus is ground truth, so en's `to` is optional and he/zh accept
           // the patient particle as a destination-marker alternative, scoped to go.
-          markerOptional: { en: true },
-          markerVariants: { he: ["\u05D0\u05EA"], zh: ["\u628A"] }
+          // The render side drops the preposition for these four, so the parse
+          // side cannot require it: `go /page`, `前往 url`, `đi đến url`, `ไป url`
+          // must parse alongside the marked forms the profile still accepts.
+          markerOptional: { en: true, zh: true, vi: true, th: true },
+          // zh renders `前往 把 back` with its PATIENT particle before go's
+          // destination — a synonym here, not a distinct shape, so it is accepted as
+          // a marker alternative scoped to go. he's `את` is the same thing and sits
+          // in `markerLegacy` below: it moved there in #763 because the two fields
+          // were then read by DIFFERENT branches, so leaving it here silently
+          // stopped `לך את back` parsing the moment he gained a `markerOverride`.
+          // Both fields now merge on both branches (`schemaMarkerAlternatives`), so
+          // that trap is gone and the split is historical.
+          markerVariants: { zh: ["\u628A"] },
+          markerLegacy: {
+            es: ["en", "sobre", "hacia"],
+            ar: ["\u0639\u0644\u0649", "\u0641\u064A", "\u0628"],
+            fr: ["sur", "dans"],
+            de: ["auf", "in"],
+            pt: ["em", "a"],
+            // `את` is he's PATIENT particle, which the transformer renders before
+            // go's destination in `go back` (`לך את back`) — a parse-only synonym
+            // here, never rendered, which is exactly what markerLegacy is for.
+            he: ["\u05E2\u05DC", "\u05D1", "\u05DC", "\u05D0\u05EA"],
+            hi: ["\u092E\u0947\u0902"],
+            id: ["pada", "di"],
+            it: ["in", "su"],
+            ru: ["\u0432", "\u043A"],
+            sw: ["kwenye"],
+            uk: ["\u0432", "\u0434\u043E"]
+            // zh, vi and th are NOT listed: none has a markerOverride, so all three
+            // stay on the profile-default branch and keep accepting their old
+            // markers from the profile itself. Only their RENDERING changed.
+            // Listing them here would be dead config — markerLegacy is read ONLY by
+            // the override branch.
+          }
         }
       ],
       // `go to url "/page"` — without this variant the destination captures the
@@ -42490,7 +42910,7 @@ var init_command_schemas = __esm({
         roles: []
       }
     };
-    if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+    if (typeof process !== "undefined" && process.env.LOKASCRIPT_SCHEMA_VALIDATION === "1") {
       Promise.resolve().then(() => (init_schema_validator(), schema_validator_exports)).then(({ validateAllSchemas: validateAllSchemas2, formatValidationResults: formatValidationResults2 }) => {
         const validations = validateAllSchemas2(commandSchemas);
         if (validations.size > 0) {
@@ -44065,10 +44485,10 @@ function extractCssSelector(input, position) {
   }
   return null;
 }
-var CssSelectorExtractor;
+var CssSelectorExtractor2;
 var init_css_selector = __esm({
   "src/tokenizers/extractors/css-selector.ts"() {
-    CssSelectorExtractor = class {
+    CssSelectorExtractor2 = class {
       constructor() {
         this.name = "css-selector";
       }
@@ -47235,7 +47655,7 @@ function getHyperscriptExtractors() {
     new UrlExtractor(),
     new EventModifierExtractor(),
     new VariableRefExtractor(),
-    new CssSelectorExtractor()
+    new CssSelectorExtractor2()
   ];
 }
 var init_extractor_helpers = __esm({
@@ -49058,12 +49478,16 @@ var init_spanish_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(word);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -49072,6 +49496,8 @@ var init_spanish_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -50198,12 +50624,16 @@ var init_portuguese_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(lower);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -50212,6 +50642,8 @@ var init_portuguese_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -50696,12 +51128,16 @@ var init_french_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(lower);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -50710,6 +51146,8 @@ var init_french_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -57343,8 +57781,10 @@ function resolveMarkerForRole(roleSpec, profile) {
   const overrideMarker = roleSpec.markerOverride?.[profile.code];
   const defaultMarker = profile.roleMarkers[roleSpec.role];
   if (overrideMarker !== void 0) {
+    const alternatives = legacyMarkerAlternatives(roleSpec, profile.code, overrideMarker);
     return {
       primary: overrideMarker,
+      ...alternatives && { alternatives },
       position: defaultMarker?.position ?? "before",
       isOverride: true
     };
@@ -57362,6 +57802,18 @@ function resolveMarkerForRole(roleSpec, profile) {
   }
   return null;
 }
+function legacyMarkerAlternatives(roleSpec, languageCode, overrideMarker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode];
+  if (!legacy?.length) return void 0;
+  const alternatives = [...new Set(legacy)].filter((a) => a && a !== overrideMarker);
+  return alternatives.length ? alternatives : void 0;
+}
+function schemaMarkerAlternatives(roleSpec, languageCode, marker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode] ?? [];
+  const variants = roleSpec.methodCarrier ? [] : roleSpec.markerVariants?.[languageCode] ?? [];
+  const alternatives = [.../* @__PURE__ */ new Set([...legacy, ...variants])].filter((a) => a && a !== marker);
+  return alternatives.length ? alternatives : void 0;
+}
 var init_marker_resolution = __esm({
   "src/parser/utils/marker-resolution.ts"() {
   }
@@ -57371,20 +57823,17 @@ function resolveRoleMarker(roleSpec, profile) {
   let alternatives;
   if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
     marker = roleSpec.markerOverride[profile.code];
+    alternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
   } else {
     const roleMarker = profile.roleMarkers[roleSpec.role];
     if (roleMarker) {
       marker = roleMarker.primary;
-      alternatives = roleMarker.alternatives ? [...roleMarker.alternatives] : void 0;
-    }
-  }
-  const variants = roleSpec.markerVariants?.[profile.code];
-  if (variants && variants.length > 0) {
-    const merged = alternatives ? [...alternatives] : [];
-    for (const v2 of variants) {
-      if (v2 !== marker && !merged.includes(v2)) merged.push(v2);
+      const schemaAlts = schemaMarkerAlternatives(roleSpec, profile.code, marker) ?? [];
+      const merged = [.../* @__PURE__ */ new Set([...roleMarker.alternatives ?? [], ...schemaAlts])].filter(
+        (a) => a !== marker
+      );
+      alternatives = merged.length ? merged : void 0;
     }
-    alternatives = merged;
   }
   return { marker, alternatives };
 }
@@ -57853,8 +58302,16 @@ function generateSOVTwoRoleDestFirstEventHandlerPattern(commandSchema, profile,
 var init_event_handlers_sov = __esm({
   "src/generators/event-handlers-sov.ts"() {
     init_command_schemas();
+    init_marker_resolution();
   }
 });
+function mergeSchemaAlternatives(roleSpec, profile, roleMarker) {
+  const schemaAlts = schemaMarkerAlternatives(roleSpec, profile.code, roleMarker.primary) ?? [];
+  const merged = [.../* @__PURE__ */ new Set([...roleMarker.alternatives ?? [], ...schemaAlts])].filter(
+    (a) => a !== roleMarker.primary
+  );
+  return merged.length ? merged : void 0;
+}
 function generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config2) {
   const tokens = [];
   if (eventMarker.position === "before") {
@@ -57967,11 +58424,12 @@ function generateVSOVerbFirstTwoRoleEventHandlerPattern(commandSchema, profile,
     let markerAlternatives;
     if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
+      markerAlternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
       if (roleMarker) {
         marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
+        markerAlternatives = mergeSchemaAlternatives(roleSpec, profile, roleMarker);
       }
     }
     if (marker) {
@@ -58024,11 +58482,12 @@ function generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword,
     let markerAlternatives;
     if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
+      markerAlternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
       if (roleMarker) {
         marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
+        markerAlternatives = mergeSchemaAlternatives(roleSpec, profile, roleMarker);
       }
     }
     if (marker) {
@@ -58161,6 +58620,7 @@ var init_event_handlers_vso = __esm({
   "src/generators/event-handlers-vso.ts"() {
     init_command_schemas();
     init_event_handlers_sov();
+    init_marker_resolution();
   }
 });
 function getAllRegisteredProfiles() {
@@ -58558,7 +59018,13 @@ function buildRoleToken(roleSpec, profile) {
     const position = defaultMarker?.position ?? "before";
     const optionalMarker = roleSpec.markerOptional?.[profile.code] === true;
     const pushWord = (word) => {
-      const literal = suppressMarker ? { type: "literal", value: word, renderSuppress: true } : { type: "literal", value: word };
+      const alternatives = markerWords.length === 1 ? schemaMarkerAlternatives(roleSpec, profile.code, word) ?? [] : [];
+      const literal = {
+        type: "literal",
+        value: word,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
       tokens.push(optionalMarker ? { type: "group", optional: true, tokens: [literal] } : literal);
     };
     if (position === "before") {
@@ -58569,10 +59035,12 @@ function buildRoleToken(roleSpec, profile) {
       for (const word of markerWords) pushWord(word);
     }
   } else if (defaultMarker) {
-    const variantAlts = roleSpec.markerVariants?.[profile.code] ?? [];
     const asMarker = () => {
       const alternatives = [
-        .../* @__PURE__ */ new Set([...defaultMarker.alternatives ?? [], ...variantAlts])
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
       ].filter((a) => a !== defaultMarker.primary);
       return {
         type: "literal",
@@ -58608,11 +59076,19 @@ function buildExtractionRules(schema, profile) {
     if (roleSpec.valuePrefixLiteral?.[profile.code]) {
       rules[roleSpec.role] = { marker: roleSpec.valuePrefixLiteral[profile.code] };
     } else if (overrideMarker !== void 0) {
-      rules[roleSpec.role] = overrideMarker ? { marker: overrideMarker } : {};
+      if (!overrideMarker) {
+        rules[roleSpec.role] = {};
+      } else {
+        const isSingleWord = !/\s/.test(overrideMarker.trim());
+        const markerAlternatives = isSingleWord ? schemaMarkerAlternatives(roleSpec, profile.code, overrideMarker) ?? [] : [];
+        rules[roleSpec.role] = markerAlternatives.length ? { marker: overrideMarker, markerAlternatives } : { marker: overrideMarker };
+      }
     } else if (defaultMarker && defaultMarker.primary) {
-      const variantAlts = roleSpec.markerVariants?.[profile.code] ?? [];
       const markerAlternatives = [
-        .../* @__PURE__ */ new Set([...defaultMarker.alternatives ?? [], ...variantAlts])
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
       ].filter((a) => a !== defaultMarker.primary);
       rules[roleSpec.role] = markerAlternatives.length ? { marker: defaultMarker.primary, markerAlternatives } : { marker: defaultMarker.primary };
     } else {
@@ -64892,6 +65368,12 @@ var _PatternMatcher2 = class _PatternMatcher3 {
     if (token.kind === "keyword" && token.value.toLowerCase() === value.toLowerCase()) {
       return "case-insensitive";
     }
+    if (token.kind === "keyword") {
+      const strippedToken = stripOptionalDiacritics(token.value).toLowerCase();
+      if (strippedToken && strippedToken === stripOptionalDiacritics(value).toLowerCase()) {
+        return "case-insensitive";
+      }
+    }
     return "none";
   }
   /**
@@ -69990,6 +70472,7 @@ function parseWithConfidence(hyperscript2, language) {
     tokensConsumed: confidenceResult.tokensConsumed
   };
 }
+init_registry();
 function toExplicit(input, sourceLanguage) {
   if (isExplicitSyntax$1(input)) {
     return input;
@@ -70030,28 +70513,22 @@ function roundTrip(input, sourceLanguage, targetLanguage) {
     matches: normalizedOriginal === normalizedRendered
   };
 }
-function getAllTranslations(input, sourceLanguage, targetLanguages = [
-  "en",
-  "ja",
-  "ar",
-  "es",
-  "ko",
-  "zh",
-  "tr",
-  "pt",
-  "fr",
-  "de",
-  "id",
-  "qu",
-  "sw"
-]) {
-  const result = {};
+function getAllTranslations(input, sourceLanguage, targetLanguages = getRegisteredLanguages()) {
+  return getAllTranslationsWithStatus(input, sourceLanguage, targetLanguages).translations;
+}
+function getAllTranslationsWithStatus(input, sourceLanguage, targetLanguages = getRegisteredLanguages()) {
+  const translations = {};
+  const failed = {};
   const node = parseAny(input, sourceLanguage);
   for (const lang of targetLanguages) {
-    result[lang] = render(node, lang);
+    try {
+      translations[lang] = render(node, lang);
+    } catch (error) {
+      failed[lang] = error instanceof Error ? error.message : String(error);
+    }
   }
-  result["explicit"] = renderExplicit$1(node);
-  return result;
+  translations["explicit"] = renderExplicit$1(node);
+  return { translations, failed };
 }
 function validateTranslation(original, translated, originalLang, translatedLang) {
   try {
@@ -77150,7 +77627,7 @@ var index$1 = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   ASTBuilder,
   get CssSelectorExtractor() {
-    return CssSelectorExtractor;
+    return CssSelectorExtractor2;
   },
   DEFAULT_CONFIDENCE_THRESHOLD,
   get EventModifierExtractor() {
@@ -77270,6 +77747,7 @@ var index$1 = /* @__PURE__ */ Object.freeze({
     return germanProfile;
   },
   getAllTranslations,
+  getAllTranslationsWithStatus,
   getCommandMapper,
   getCommandType,
   getDefaultExtractors,
@@ -85906,4 +86384,4 @@ export {
   toCoreAST,
   validatePartialContent
 };
-//# sourceMappingURL=dist-DIXYSN7G.js.map
+//# sourceMappingURL=dist-EFDE4LTF.js.map