@lokascript/framework 2.0.0 → 2.2.0

package/dist/api/index.js

@@ -11,6 +11,65 @@ function createReference(value) {
 function createPropertyPath(object, property) {
   return { type: "property-path", object, property };
 }
+function createFlag(name, enabled = true) {
+  return { type: "flag", name, enabled };
+}
+function createCommandNode(action, roles, metadata) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const node = {
+    kind: "command",
+    action,
+    roles: rolesMap
+  };
+  if (metadata) {
+    return { ...node, metadata };
+  }
+  return node;
+}
+function createEventHandlerNode(action, roles, body, metadata, eventModifiers) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const base = {
+    kind: "event-handler",
+    action,
+    roles: rolesMap,
+    body
+  };
+  return {
+    ...base,
+    ...eventModifiers && { eventModifiers },
+    ...metadata && { metadata }
+  };
+}
+function createConditionalNode(action, roles, thenBranch, elseBranch, metadata) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const base = {
+    kind: "conditional",
+    action,
+    roles: rolesMap,
+    thenBranch
+  };
+  return {
+    ...base,
+    ...elseBranch && { elseBranch },
+    ...metadata && { metadata }
+  };
+}
+function createLoopNode(action, roles, loopVariant, body, loopVariable, indexVariable, metadata) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const base = {
+    kind: "loop",
+    action,
+    roles: rolesMap,
+    loopVariant,
+    body
+  };
+  return {
+    ...base,
+    ...loopVariable && { loopVariable },
+    ...indexVariable && { indexVariable },
+    ...metadata && { metadata }
+  };
+}
 
 // src/core/logger.ts
 var DebugLogger = class {
@@ -224,7 +283,7 @@ var _PatternMatcher = class _PatternMatcher {
    * a token and the immediately following pattern token fails, the matcher
    * resets to before the optional role and retries the failed token.
    */
-  matchTokenSequence(tokens, patternTokens, captured) {
+  matchTokenSequence(tokens, patternTokens, captured, parentStopMarkers) {
     const firstPatternToken = patternTokens[0];
     const patternExpectsConjunction = firstPatternToken?.type === "literal" && (firstPatternToken.value === "and" || firstPatternToken.value === "then" || firstPatternToken.alternatives?.includes("and") || firstPatternToken.alternatives?.includes("then"));
     if (this.currentProfile?.code === "ar" && !patternExpectsConjunction) {
@@ -248,6 +307,9 @@ var _PatternMatcher = class _PatternMatcher {
       );
       if (patternToken.type === "role" && patternToken.greedy) {
         const stopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+        if (parentStopMarkers) {
+          for (const m of parentStopMarkers) stopMarkers.add(m);
+        }
         const values = [];
         while (!tokens.isAtEnd()) {
           const nextToken = tokens.peek();
@@ -267,8 +329,58 @@ var _PatternMatcher = class _PatternMatcher {
           return false;
         }
       }
+      if (patternToken.type === "group") {
+        const siblingStopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+        if (parentStopMarkers) {
+          for (const m of parentStopMarkers) siblingStopMarkers.add(m);
+        }
+        const groupMatched = this.matchGroupToken(
+          tokens,
+          patternToken,
+          captured,
+          siblingStopMarkers
+        );
+        if (groupMatched) {
+          prevOptionalMark = null;
+          prevOptionalRole = null;
+          continue;
+        }
+        if (this.isOptional(patternToken)) {
+          continue;
+        }
+        return false;
+      }
       const isOptionalRole = patternToken.type === "role" && patternToken.optional === true;
       const markBefore = isOptionalRole ? tokens.mark() : null;
+      const isRoleToken = patternToken.type === "role";
+      if (isRoleToken && !isOptionalRole) {
+        const nextPT = i + 1 < patternTokens.length ? patternTokens[i + 1] : null;
+        if (nextPT?.type === "literal") {
+          const currentToken = tokens.peek();
+          if (currentToken && this.getMatchType(currentToken, nextPT.value) !== "none") {
+            this.logger.debug(
+              "  >> MARKER-STEAL GUARD: current token matches next literal, skipping role"
+            );
+            this.logger.debug("  >> Token match FAILED");
+            if (this.isOptional(patternToken)) {
+              continue;
+            }
+            if (prevOptionalMark && prevOptionalRole) {
+              this.logger.debug("  >> BACKTRACKING: undoing optional role", prevOptionalRole);
+              tokens.reset(prevOptionalMark);
+              captured.delete(prevOptionalRole);
+              prevOptionalMark = null;
+              prevOptionalRole = null;
+              const retryMatched = this.matchPatternToken(tokens, patternToken, captured);
+              this.logger.debug("  >> Backtrack retry result:", retryMatched);
+              if (retryMatched) {
+                continue;
+              }
+            }
+            return false;
+          }
+        }
+      }
       const matched = this.matchPatternToken(tokens, patternToken, captured);
       this.logger.debug("  >> Match result:", matched);
       if (matched) {
@@ -389,7 +501,7 @@ var _PatternMatcher = class _PatternMatcher {
     const possessiveValue = this.tryMatchPossessiveExpression(tokens);
     if (possessiveValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(possessiveValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible(possessiveValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -399,7 +511,7 @@ var _PatternMatcher = class _PatternMatcher {
     const methodCallValue = this.tryMatchMethodCallExpression(tokens);
     if (methodCallValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(methodCallValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible(methodCallValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -419,7 +531,7 @@ var _PatternMatcher = class _PatternMatcher {
     const propertyAccessValue = this.tryMatchPropertyAccessExpression(tokens);
     if (propertyAccessValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(propertyAccessValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible(propertyAccessValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -739,10 +851,15 @@ var _PatternMatcher = class _PatternMatcher {
    * (e.g., a value like 'hello') to sit between groups without blocking later
    * marker matches.
    */
-  matchGroupToken(tokens, patternToken, captured) {
+  matchGroupToken(tokens, patternToken, captured, parentStopMarkers) {
     const mark = tokens.mark();
     const capturedBefore = new Set(captured.keys());
-    const success = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+    const success = this.matchTokenSequence(
+      tokens,
+      patternToken.tokens,
+      captured,
+      parentStopMarkers
+    );
     if (success) return true;
     tokens.reset(mark);
     for (const role of captured.keys()) {
@@ -764,7 +881,12 @@ var _PatternMatcher = class _PatternMatcher {
             "- skipping intervening tokens"
           );
           for (let s = 0; s < offset; s++) tokens.advance();
-          const retrySuccess = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+          const retrySuccess = this.matchTokenSequence(
+            tokens,
+            patternToken.tokens,
+            captured,
+            parentStopMarkers
+          );
           if (retrySuccess) return true;
           tokens.reset(mark);
           for (const role of captured.keys()) {
@@ -831,7 +953,7 @@ var _PatternMatcher = class _PatternMatcher {
             break;
           }
         }
-        break;
+        if (!pt.optional) break;
       }
     }
     return markers;
@@ -841,8 +963,9 @@ var _PatternMatcher = class _PatternMatcher {
    */
   isStopMarker(token, stopMarkers) {
     if (stopMarkers.size === 0) return false;
-    const value = (token.normalized || token.value).toLowerCase();
-    return stopMarkers.has(value);
+    if (stopMarkers.has(token.value.toLowerCase())) return true;
+    if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
+    return false;
   }
   /**
    * Convert a language token to a semantic value.
@@ -1241,7 +1364,7 @@ function addRoleWithMarker(tokens, roleSpec, profile) {
   if (marker) {
     const markerInfo = profile.roleMarkers?.[roleSpec.role];
     const defaultPosition = profile.wordOrder === "SOV" ? "after" : "before";
-    const position = markerInfo?.position ?? defaultPosition;
+    const position = roleSpec.markerPosition ?? markerInfo?.position ?? defaultPosition;
     if (isOptional) {
       if (position === "before") {
         tokens.push({
@@ -1534,6 +1657,455 @@ var InMemoryProfileProvider = class {
   }
 };
 
+// src/ir/references.ts
+var DEFAULT_REFERENCES = /* @__PURE__ */ new Set([
+  "me",
+  "you",
+  "it",
+  "result",
+  "event",
+  "target",
+  "body"
+]);
+function isValidReference2(value, referenceSet = DEFAULT_REFERENCES) {
+  return referenceSet.has(value);
+}
+
+// src/ir/explicit-parser.ts
+var STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "body",
+  "then",
+  "else",
+  "condition",
+  "loop-body",
+  "variable",
+  "catch",
+  // v1.2: try/catch/finally
+  "finally"
+  // v1.2: try/catch/finally
+]);
+function isNestedCommand(value) {
+  const inner = value.slice(1, -1);
+  let depth = 0;
+  for (const ch of inner) {
+    if (ch === "[") depth++;
+    else if (ch === "]") depth--;
+    else if (depth === 0 && (ch === " " || ch === ":")) return true;
+  }
+  return false;
+}
+function parseExplicit(input, options = {}) {
+  const trimmed = input.trim();
+  const collect = options.collectDiagnostics === true;
+  const diagnostics = [];
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+    throw new Error("Explicit syntax must be wrapped in brackets: [command role:value ...]");
+  }
+  const content = trimmed.slice(1, -1).trim();
+  if (!content) {
+    throw new Error("Empty explicit statement");
+  }
+  const tokens = tokenizeExplicit(content);
+  if (tokens.length === 0) {
+    throw new Error("No command specified in explicit statement");
+  }
+  const command = tokens[0].toLowerCase();
+  const roles = /* @__PURE__ */ new Map();
+  const refSet = options.referenceSet ?? DEFAULT_REFERENCES;
+  const schema = options.schemaLookup?.getSchema(command);
+  const validRoleNames = schema ? new Set(schema.roles.map((r) => r.role)) : null;
+  for (let i = 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith("+") || token.startsWith("~")) {
+      const enabled = token.startsWith("+");
+      const flagName = token.slice(1);
+      if (!flagName) {
+        if (collect) {
+          diagnostics.push({
+            severity: "error",
+            code: "EMPTY_FLAG",
+            message: `Empty flag name: "${token}"`,
+            source: "schema"
+          });
+          continue;
+        }
+        throw new Error(`Empty flag name: "${token}"`);
+      }
+      if (validRoleNames && !validRoleNames.has(flagName)) {
+        const roleList = [...validRoleNames].join(", ");
+        if (collect) {
+          diagnostics.push({
+            severity: "error",
+            code: "UNKNOWN_FLAG",
+            message: `Unknown flag "${flagName}" for command "${command}"`,
+            source: "schema",
+            suggestions: [...validRoleNames].map((r) => `+${r}`)
+          });
+          roles.set(flagName, createFlag(flagName, enabled));
+          continue;
+        }
+        throw new Error(
+          `Unknown flag "${flagName}" for command "${command}". Valid roles: ${roleList}`
+        );
+      }
+      roles.set(flagName, createFlag(flagName, enabled));
+      continue;
+    }
+    const colonIndex = token.indexOf(":");
+    if (colonIndex === -1) {
+      if (collect) {
+        diagnostics.push({
+          severity: "error",
+          code: "INVALID_ROLE_FORMAT",
+          message: `Invalid role format: "${token}". Expected role:value or +flag`,
+          source: "schema"
+        });
+        continue;
+      }
+      throw new Error(`Invalid role format: "${token}". Expected role:value or +flag`);
+    }
+    const roleName = token.slice(0, colonIndex);
+    if (validRoleNames && !STRUCTURAL_ROLES.has(roleName) && !validRoleNames.has(roleName)) {
+      const roleList = [...validRoleNames].join(", ");
+      if (collect) {
+        diagnostics.push({
+          severity: "error",
+          code: "UNKNOWN_ROLE",
+          message: `Unknown role "${roleName}" for command "${command}"`,
+          source: "schema",
+          suggestions: [...validRoleNames]
+        });
+      } else {
+        throw new Error(
+          `Unknown role "${roleName}" for command "${command}". Valid roles: ${roleList}`
+        );
+      }
+    }
+    const role = roleName;
+    const valueStr = token.slice(colonIndex + 1);
+    if (STRUCTURAL_ROLES.has(roleName) && valueStr.startsWith("[") && isNestedCommand(valueStr)) {
+      const nestedEnd = findMatchingBracket(token, colonIndex + 1);
+      const nestedSyntax = token.slice(colonIndex + 1, nestedEnd + 1);
+      roles.set(role, { type: "expression", raw: nestedSyntax });
+      continue;
+    }
+    const value = parseExplicitValue(valueStr, refSet);
+    roles.set(role, value);
+  }
+  if (schema && command !== "on") {
+    for (const roleSpec of schema.roles) {
+      if (roleSpec.required && !roles.has(roleSpec.role) && !roleSpec.default) {
+        if (collect) {
+          diagnostics.push({
+            severity: "error",
+            code: "MISSING_REQUIRED_ROLE",
+            message: `Missing required role "${roleSpec.role}" for command "${command}": ${roleSpec.description}`,
+            source: "schema"
+          });
+        } else {
+          throw new Error(
+            `Missing required role "${roleSpec.role}" for command "${command}": ${roleSpec.description}`
+          );
+        }
+      }
+    }
+  }
+  const attachDiagnostics = (node) => {
+    if (diagnostics.length === 0) return node;
+    return { ...node, diagnostics };
+  };
+  switch (command) {
+    case "on": {
+      const eventValue = roles.get("event");
+      if (!eventValue) {
+        if (collect) {
+          diagnostics.push({
+            severity: "error",
+            code: "MISSING_EVENT_ROLE",
+            message: "Event handler requires event role: [on event:click ...]",
+            source: "schema"
+          });
+          return attachDiagnostics(
+            createEventHandlerNode("on", roles, [], {
+              sourceLanguage: "explicit"
+            })
+          );
+        }
+        throw new Error("Event handler requires event role: [on event:click ...]");
+      }
+      const body = extractStructuralBody(roles, "body", options);
+      roles.delete("body");
+      return attachDiagnostics(
+        createEventHandlerNode("on", roles, body, {
+          sourceLanguage: "explicit"
+        })
+      );
+    }
+    case "if": {
+      const thenBranch = extractStructuralBody(roles, "then", options);
+      const elseBranch = extractStructuralBody(roles, "else", options);
+      roles.delete("then");
+      roles.delete("else");
+      return attachDiagnostics(
+        createConditionalNode(
+          command,
+          roles,
+          thenBranch,
+          elseBranch.length > 0 ? elseBranch : void 0,
+          {
+            sourceLanguage: "explicit"
+          }
+        )
+      );
+    }
+    case "repeat": {
+      const loopBody = extractStructuralBody(roles, "loop-body", options);
+      const loopVariantValue = roles.get("loop-variant");
+      const variableValue = roles.get("variable");
+      const indexVariableValue = roles.get("index-variable");
+      roles.delete("loop-body");
+      roles.delete("loop-variant");
+      roles.delete("variable");
+      roles.delete("index-variable");
+      let variant;
+      if (loopVariantValue && loopVariantValue.type === "literal" && typeof loopVariantValue.value === "string") {
+        variant = loopVariantValue.value;
+      } else if (roles.has("quantity")) {
+        variant = "times";
+      } else if (roles.has("source")) {
+        variant = "for";
+      } else if (roles.has("condition")) {
+        variant = "while";
+      } else {
+        variant = "forever";
+      }
+      const loopVariable = variableValue?.type === "literal" && typeof variableValue.value === "string" ? variableValue.value : variableValue?.type === "expression" ? variableValue.raw : void 0;
+      const indexVariable = indexVariableValue?.type === "literal" && typeof indexVariableValue.value === "string" ? indexVariableValue.value : void 0;
+      return attachDiagnostics(
+        createLoopNode(command, roles, variant, loopBody, loopVariable, indexVariable, {
+          sourceLanguage: "explicit"
+        })
+      );
+    }
+    default:
+      return attachDiagnostics(
+        createCommandNode(command, roles, {
+          sourceLanguage: "explicit"
+        })
+      );
+  }
+}
+function isExplicitSyntax(input) {
+  const trimmed = input.trim();
+  return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+function extractStructuralBody(roles, roleName, options) {
+  const value = roles.get(roleName);
+  if (!value) return [];
+  if (value.type === "expression") {
+    return [parseExplicit(value.raw, options)];
+  }
+  return [];
+}
+function inferSelectorKind(value) {
+  if (!value) return void 0;
+  if (value.startsWith("#")) return "id";
+  if (value.startsWith(".")) return "class";
+  if (value.startsWith("[")) return "attribute";
+  if (value.startsWith("<") || value.startsWith("*")) return "element";
+  if (/[>+~ ]/.test(value) && value.length > 1) return "complex";
+  return void 0;
+}
+function tokenizeExplicit(content) {
+  const tokens = [];
+  let current = "";
+  let inString = false;
+  let stringChar = "";
+  let bracketDepth = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    if (inString) {
+      current += char;
+      if (char === stringChar && content[i - 1] !== "\\") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inString = true;
+      stringChar = char;
+      current += char;
+      continue;
+    }
+    if (char === "[") {
+      bracketDepth++;
+      current += char;
+      continue;
+    }
+    if (char === "]") {
+      bracketDepth--;
+      current += char;
+      continue;
+    }
+    if (char === " " && bracketDepth === 0) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function parseExplicitValue(valueStr, referenceSet) {
+  if (valueStr.startsWith("#") || valueStr.startsWith(".") || valueStr.startsWith("[") || valueStr.startsWith("@") || valueStr.startsWith("*")) {
+    return createSelector(valueStr, inferSelectorKind(valueStr));
+  }
+  if (valueStr.startsWith('"') || valueStr.startsWith("'")) {
+    const inner = valueStr.slice(1, -1);
+    return createLiteral(inner, "string");
+  }
+  if (valueStr === "true") return createLiteral(true, "boolean");
+  if (valueStr === "false") return createLiteral(false, "boolean");
+  const lowerRef = valueStr.toLowerCase();
+  if (isValidReference2(lowerRef, referenceSet)) {
+    return createReference(lowerRef);
+  }
+  const numMatch = valueStr.match(/^(-?\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (numMatch) {
+    const num = parseFloat(numMatch[1]);
+    const suffix = numMatch[2];
+    if (suffix) {
+      return createLiteral(valueStr, "duration");
+    }
+    return createLiteral(num, "number");
+  }
+  return createLiteral(valueStr);
+}
+function findMatchingBracket(str, start) {
+  let depth = 0;
+  for (let i = start; i < str.length; i++) {
+    if (str[i] === "[") depth++;
+    else if (str[i] === "]") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return str.length - 1;
+}
+
+// src/ir/explicit-renderer.ts
+function renderExplicit(node) {
+  let result;
+  if (node.kind === "compound") {
+    const compoundNode = node;
+    const renderedStatements = compoundNode.statements.map((stmt) => renderExplicit(stmt));
+    result = renderedStatements.join(` ${compoundNode.chainType} `);
+  } else {
+    result = renderBracketCommand(node);
+  }
+  if (node.annotations && node.annotations.length > 0) {
+    const annParts = node.annotations.map(
+      (ann) => ann.value !== void 0 ? `@${ann.name}(${ann.value})` : `@${ann.name}`
+    );
+    return annParts.join(" ") + " " + result;
+  }
+  return result;
+}
+function renderBracketCommand(node) {
+  const parts = [node.action];
+  for (const [role, value] of node.roles) {
+    if (value.type === "flag") {
+      parts.push(value.enabled ? `+${value.name}` : `~${value.name}`);
+    } else {
+      parts.push(`${role}:${valueToString(value)}`);
+    }
+  }
+  if (node.kind === "event-handler") {
+    const eventNode = node;
+    if (eventNode.body && eventNode.body.length > 0) {
+      const bodyParts = eventNode.body.map((n) => renderExplicit(n));
+      parts.push(`body:${bodyParts.join(" ")}`);
+    }
+  }
+  if (node.kind === "conditional") {
+    const condNode = node;
+    if (condNode.thenBranch && condNode.thenBranch.length > 0) {
+      const thenParts = condNode.thenBranch.map((n) => renderExplicit(n));
+      parts.push(`then:${thenParts.join(" ")}`);
+    }
+    if (condNode.elseBranch && condNode.elseBranch.length > 0) {
+      const elseParts = condNode.elseBranch.map((n) => renderExplicit(n));
+      parts.push(`else:${elseParts.join(" ")}`);
+    }
+  }
+  if (node.kind === "loop") {
+    const loopNode = node;
+    if (loopNode.loopVariant) {
+      parts.push(`loop-variant:${loopNode.loopVariant}`);
+    }
+    if (loopNode.loopVariable) {
+      parts.push(`variable:${loopNode.loopVariable}`);
+    }
+    if (loopNode.indexVariable) {
+      parts.push(`index-variable:${loopNode.indexVariable}`);
+    }
+    if (loopNode.body && loopNode.body.length > 0) {
+      const bodyParts = loopNode.body.map((n) => renderExplicit(n));
+      parts.push(`loop-body:${bodyParts.join(" ")}`);
+    }
+  }
+  if (node.kind === "command") {
+    const cmd = node;
+    if (cmd.body && cmd.body.length > 0) {
+      const bodyParts = cmd.body.map((n) => renderExplicit(n));
+      parts.push(`body:${bodyParts.join(" ")}`);
+    }
+    if (cmd.catchBranch && cmd.catchBranch.length > 0) {
+      const catchParts = cmd.catchBranch.map((n) => renderExplicit(n));
+      parts.push(`catch:${catchParts.join(" ")}`);
+    }
+    if (cmd.finallyBranch && cmd.finallyBranch.length > 0) {
+      const finallyParts = cmd.finallyBranch.map((n) => renderExplicit(n));
+      parts.push(`finally:${finallyParts.join(" ")}`);
+    }
+    if (cmd.asyncVariant) {
+      parts.push(`async-variant:${cmd.asyncVariant}`);
+    }
+    if (cmd.asyncBody && cmd.asyncBody.length > 0) {
+      const asyncParts = cmd.asyncBody.map((n) => renderExplicit(n));
+      parts.push(`async-body:${asyncParts.join(" ")}`);
+    }
+  }
+  return `[${parts.join(" ")}]`;
+}
+function valueToString(value) {
+  switch (value.type) {
+    case "literal":
+      if (typeof value.value === "string") {
+        if (value.dataType === "string" || /\s/.test(value.value)) {
+          return `"${value.value}"`;
+        }
+        return value.value;
+      }
+      return String(value.value);
+    case "selector":
+      return value.value;
+    case "reference":
+      return value.value;
+    case "property-path":
+      return `${valueToString(value.object)}'s ${value.property}`;
+    case "expression":
+      return value.raw;
+    case "flag":
+      return value.name;
+  }
+}
+
 // src/api/create-dsl.ts
 var DSLRegistry = class {
   constructor(config) {
@@ -1571,12 +2143,23 @@ var MultilingualDSLImpl = class {
     if (config.codeGenerator) {
       this.codeGenerator = config.codeGenerator;
     }
+    const schemaMap = new Map(config.schemas.map((s) => [s.action, s]));
+    this.schemaLookup = {
+      getSchema: (action) => schemaMap.get(action)
+    };
   }
   parse(input, language) {
     const result = this.parseWithConfidence(input, language);
     return result.node;
   }
   parseWithConfidence(input, language) {
+    if (isExplicitSyntax(input)) {
+      const node = parseExplicit(input, { schemaLookup: this.schemaLookup });
+      if (!this.schemaLookup.getSchema(node.action)) {
+        throw new Error(`No schema for action "${node.action}" in this DSL`);
+      }
+      return { node, confidence: 1 };
+    }
     const tokenizer = this.registry.getTokenizer(language);
     if (!tokenizer) {
       throw new Error(`No tokenizer registered for language: ${language}`);
@@ -1620,6 +2203,7 @@ var MultilingualDSLImpl = class {
     }
   }
   translate(input, fromLanguage, toLanguage) {
+    if (isExplicitSyntax(input)) return input;
     return this.transformer.transform(input, fromLanguage, toLanguage);
   }
   compile(input, language) {
@@ -1683,6 +2267,723 @@ function createMultilingualDSL(config) {
   return new MultilingualDSLImpl(config, registry, transformer);
 }
 
+// src/prompts/prompt-generator.ts
+function generatePrompt(config) {
+  const outputFormat = config.outputFormat ?? "both";
+  const examplesPerCommand = config.examplesPerCommand ?? 2;
+  const sections = [
+    buildProtocolSection(),
+    buildValueTypeSection(),
+    buildCommandsSection(config.schemas, outputFormat, examplesPerCommand),
+    buildOutputFormatSection(outputFormat),
+    buildErrorRecoverySection()
+  ];
+  let finalSections = sections;
+  if (config.maxTokens && config.maxTokens > 0) {
+    finalSections = truncateToTokenBudget(sections, config.maxTokens);
+  }
+  const text = finalSections.map((s) => `## ${s.title}
+
+${s.content}`).join("\n\n---\n\n");
+  const totalRoles = config.schemas.reduce((sum, s) => sum + s.roles.length, 0);
+  const approximateTokens = estimateTokens(text);
+  const metadata = {
+    domain: config.domain,
+    commandCount: config.schemas.length,
+    roleCount: totalRoles,
+    approximateTokens
+  };
+  return { text, sections: finalSections, metadata };
+}
+function generateExamples(schema, count = 2) {
+  const combos = generateRoleCombinations(schema);
+  const examples = [];
+  for (let i = 0; i < Math.min(count, combos.length); i++) {
+    const combo = combos[i];
+    const roles = /* @__PURE__ */ new Map();
+    for (const role of combo) {
+      const sample = sampleValue(role);
+      roles.set(role.role, sample);
+    }
+    const nodeRoles = /* @__PURE__ */ new Map();
+    for (const [roleName, sample] of roles) {
+      nodeRoles.set(roleName, toSemanticValue(sample));
+    }
+    const node = createCommandNode(schema.action, nodeRoles);
+    const explicit = renderExplicit(node);
+    const jsonRoles = {};
+    for (const [roleName, sample] of roles) {
+      jsonRoles[roleName] = sample;
+    }
+    const json = { action: schema.action, roles: jsonRoles };
+    examples.push({ explicit, json });
+  }
+  return examples;
+}
+function buildProtocolSection() {
+  const content = `LokaScript Explicit Syntax (LSE) is a bracket-based format for imperative commands.
+
+### Syntax
+
+\`\`\`
+[command role1:value1 role2:value2 +flag1 ~flag2]
+\`\`\`
+
+- **Command**: The first token inside brackets (lowercased)
+- **Role pair**: \`name:value\` \u2014 a named semantic role with a typed value (no space around colon)
+- **Enabled flag**: \`+name\` \u2014 boolean attribute present
+- **Disabled flag**: \`~name\` \u2014 boolean attribute negated
+- **Nested body**: \`body:[command ...]\` \u2014 a bracket command inside a role value
+
+### Rules
+
+1. Commands are always lowercased
+2. Role names preserve their original case
+3. No spaces around the colon in role:value pairs
+4. Strings with spaces must be quoted: \`patient:"hello world"\`
+5. Selectors start with \`#\`, \`.\`, \`[\`, \`@\`, or \`*\`
+6. Output must be valid bracket syntax: \`[action role:value ...]\``;
+  return {
+    id: "protocol",
+    title: "LSE Protocol",
+    content,
+    approximateTokens: estimateTokens(content)
+  };
+}
+function buildValueTypeSection() {
+  const content = `Values in LSE are classified by their syntactic form (first match wins):
+
+| Type | Syntax | Example |
+|------|--------|---------|
+| Selector | Starts with \`#\` \`.\` \`[\` \`@\` \`*\` | \`#button\`, \`.active\`, \`[data-id]\` |
+| String | Quoted with \`"\` or \`'\` | \`"hello world"\`, \`'json'\` |
+| Boolean | Exact: \`true\` / \`false\` | \`visible:true\` |
+| Reference | Built-in name | \`me\`, \`you\`, \`it\`, \`result\`, \`event\`, \`target\`, \`body\` |
+| Duration | Number + suffix | \`500ms\`, \`2s\`, \`1m\`, \`1h\` |
+| Number | Digits with optional decimal | \`5\`, \`3.14\`, \`-1\` |
+| Plain | Fallback (any non-whitespace) | \`/api/users\`, \`json\`, \`production\` |
+
+**Important**: Classification is by prefix, not by intent. \`#true\` is a selector (not boolean). \`event\` as a value is a reference (not plain text).`;
+  return {
+    id: "value-types",
+    title: "Value Types",
+    content,
+    approximateTokens: estimateTokens(content)
+  };
+}
+function buildCommandsSection(schemas, outputFormat, examplesPerCommand) {
+  const parts = [];
+  for (const schema of schemas) {
+    parts.push(formatCommandDoc(schema, outputFormat, examplesPerCommand));
+  }
+  const content = parts.join("\n\n");
+  return {
+    id: "commands",
+    title: "Available Commands",
+    content,
+    approximateTokens: estimateTokens(content)
+  };
+}
+function buildOutputFormatSection(outputFormat) {
+  let content;
+  if (outputFormat === "explicit") {
+    content = `Output valid LSE bracket syntax. Each command must be wrapped in brackets:
+
+\`\`\`
+[command role:value ...]
+\`\`\`
+
+Do NOT output JSON. Only use bracket syntax.`;
+  } else if (outputFormat === "json") {
+    content = `Output valid JSON in the LLM-simplified format:
+
+\`\`\`json
+{
+  "action": "command-name",
+  "roles": {
+    "roleName": { "type": "valueType", "value": "theValue" }
+  }
+}
+\`\`\`
+
+Valid value types: \`selector\`, \`literal\`, \`reference\`, \`expression\`.
+Do NOT output bracket syntax. Only use JSON.`;
+  } else {
+    content = `You may output EITHER format:
+
+**Bracket syntax** (preferred for single commands):
+\`\`\`
+[command role:value ...]
+\`\`\`
+
+**JSON format** (preferred when structured data is needed):
+\`\`\`json
+{
+  "action": "command-name",
+  "roles": {
+    "roleName": { "type": "valueType", "value": "theValue" }
+  }
+}
+\`\`\`
+
+Both formats are equally valid. Use whichever is more natural for the context.`;
+  }
+  return {
+    id: "output-format",
+    title: "Output Format",
+    content,
+    approximateTokens: estimateTokens(content)
+  };
+}
+function buildErrorRecoverySection() {
+  const content = `If you're unsure about a command or role:
+
+1. **Unknown command**: Use the closest matching command from the Available Commands section. Do not invent commands.
+2. **Unknown role**: Use only the roles listed for each command. Do not add roles not in the schema.
+3. **Ambiguous value type**: When in doubt, use \`expression\` type (it's the most permissive).
+4. **Missing required role**: Always include all required roles. Check the Required/Optional labels.
+5. **Selector vs plain value**: If a value starts with \`#\`, \`.\`, \`[\`, \`@\`, or \`*\`, it's a selector. URLs like \`/api/data\` are plain values.
+
+When generating LSE, prefer explicit role labeling over positional guessing. Every value should have a role name.`;
+  return {
+    id: "error-recovery",
+    title: "Error Recovery",
+    content,
+    approximateTokens: estimateTokens(content)
+  };
+}
+function formatCommandDoc(schema, outputFormat, examplesPerCommand) {
+  const lines = [];
+  lines.push(`### \`${schema.action}\` \u2014 ${schema.description}`);
+  lines.push("");
+  const required = schema.roles.filter((r) => r.required);
+  const optional = schema.roles.filter((r) => !r.required);
+  if (required.length > 0) {
+    lines.push("**Required roles:**");
+    for (const role of required) {
+      lines.push(`- \`${role.role}\`: ${role.description} (type: ${formatExpectedTypes(role)})`);
+    }
+  }
+  if (optional.length > 0) {
+    lines.push("**Optional roles:**");
+    for (const role of optional) {
+      lines.push(`- \`${role.role}\`: ${role.description} (type: ${formatExpectedTypes(role)})`);
+    }
+  }
+  const examples = generateExamples(schema, examplesPerCommand);
+  if (examples.length > 0) {
+    lines.push("");
+    if (outputFormat === "explicit" || outputFormat === "both") {
+      lines.push("**Bracket syntax:**");
+      for (const ex of examples) {
+        lines.push(`\`\`\`
+${ex.explicit}
+\`\`\``);
+      }
+    }
+    if (outputFormat === "json" || outputFormat === "both") {
+      lines.push("**JSON format:**");
+      for (const ex of examples) {
+        lines.push(`\`\`\`json
+${JSON.stringify(ex.json, null, 2)}
+\`\`\``);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatExpectedTypes(role) {
+  return role.expectedTypes.join(" | ");
+}
+function generateRoleCombinations(schema) {
+  const required = schema.roles.filter((r) => r.required);
+  const optional = schema.roles.filter((r) => !r.required);
+  const combos = [];
+  if (required.length > 0) {
+    combos.push(required);
+  }
+  for (const opt of optional) {
+    combos.push([...required, opt]);
+  }
+  if (optional.length >= 2) {
+    combos.push([...required, ...optional]);
+  }
+  if (combos.length === 0) {
+    combos.push(schema.roles.slice());
+  }
+  return combos;
+}
+function sampleValue(role) {
+  const primaryType = role.expectedTypes[0] || "expression";
+  switch (primaryType) {
+    case "selector":
+      return sampleSelector(role.role);
+    case "literal":
+      return sampleLiteral(role.role);
+    case "reference":
+      return { type: "reference", value: "me" };
+    case "expression":
+      return sampleExpression(role.role);
+    case "flag":
+      return { type: "flag", value: true };
+    default:
+      return { type: "literal", value: "example" };
+  }
+}
+function sampleSelector(roleName) {
+  const selectors = {
+    patient: ".active",
+    destination: "#output",
+    source: "#input",
+    target: "#target"
+  };
+  return { type: "selector", value: selectors[roleName] || `#${roleName}` };
+}
+function sampleLiteral(roleName) {
+  const literals = {
+    duration: "30s",
+    interval: "5s",
+    delay: "500ms",
+    timeout: "10s",
+    quantity: 5,
+    limit: 10,
+    style: "json",
+    manner: "rolling",
+    format: "html"
+  };
+  return { type: "literal", value: literals[roleName] || roleName };
+}
+function sampleExpression(roleName) {
+  const expressions = {
+    source: "/api/data",
+    destination: "#output",
+    patient: ".active",
+    instrument: "toUpperCase",
+    condition: "age > 18",
+    style: "json",
+    duration: "5s",
+    url: "/api/users"
+  };
+  return { type: "expression", value: expressions[roleName] || `/api/${roleName}` };
+}
+function toSemanticValue(sample) {
+  switch (sample.type) {
+    case "selector":
+      return {
+        type: "selector",
+        value: String(sample.value),
+        selectorKind: detectSelectorKind(String(sample.value))
+      };
+    case "literal":
+      return {
+        type: "literal",
+        value: sample.value,
+        dataType: typeof sample.value === "number" ? "number" : typeof sample.value === "boolean" ? "boolean" : "string"
+      };
+    case "reference":
+      return { type: "reference", value: String(sample.value) };
+    case "expression":
+      return { type: "expression", value: String(sample.value), raw: String(sample.value) };
+    case "flag":
+      return { type: "flag", value: sample.value };
+    default:
+      return { type: "literal", value: String(sample.value), dataType: "string" };
+  }
+}
+function detectSelectorKind(selector) {
+  if (selector.startsWith("#")) return "id";
+  if (selector.startsWith(".")) return "class";
+  if (selector.startsWith("[")) return "attribute";
+  return "complex";
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateToTokenBudget(sections, maxTokens) {
+  const result = [];
+  let budget = maxTokens;
+  for (const section of sections) {
+    if (section.approximateTokens <= budget) {
+      result.push(section);
+      budget -= section.approximateTokens;
+    } else {
+      const charBudget = Math.max(budget * 4, 40);
+      const truncatedContent = section.content.slice(0, charBudget) + "\n\n*(truncated)*";
+      result.push({
+        ...section,
+        content: truncatedContent,
+        approximateTokens: estimateTokens(truncatedContent)
+      });
+      break;
+    }
+  }
+  return result;
+}
+
+// src/training/schema-synthesizer.ts
+function synthesizeFromSchemas(schemas, config) {
+  const maxPerCommand = config.maxPairsPerCommand ?? 5;
+  const minQuality = config.minQuality ?? 0.5;
+  const shuffleRoles = config.shuffleRoles ?? true;
+  const languages = config.languages ?? ["en"];
+  const pairs = [];
+  let idCounter = 0;
+  for (const schema of schemas) {
+    const combos = generateRoleCombinations2(schema);
+    for (const language of languages) {
+      let commandPairCount = 0;
+      for (const combo of combos) {
+        if (commandPairCount >= maxPerCommand) break;
+        const pair = buildTrainingPair(
+          schema,
+          combo,
+          language,
+          config.domain,
+          `${config.domain}-synth-${idCounter++}`
+        );
+        if (pair.quality >= minQuality) {
+          pairs.push(pair);
+          commandPairCount++;
+        }
+        if (shuffleRoles && combo.length >= 2 && commandPairCount < maxPerCommand) {
+          const shuffled = [...combo].reverse();
+          const shuffledPair = buildTrainingPair(
+            schema,
+            shuffled,
+            language,
+            config.domain,
+            `${config.domain}-synth-${idCounter++}`
+          );
+          if (shuffledPair.quality >= minQuality) {
+            pairs.push(shuffledPair);
+            commandPairCount++;
+          }
+        }
+      }
+    }
+  }
+  const metadata = {
+    domain: config.domain,
+    commandCount: schemas.length,
+    pairCount: pairs.length,
+    bySource: { synthetic: pairs.length },
+    languages
+  };
+  return { pairs, metadata };
+}
+function generateRoleCombinations2(schema) {
+  const required = schema.roles.filter((r) => r.required);
+  const optional = schema.roles.filter((r) => !r.required);
+  const combos = [];
+  if (required.length > 0) {
+    combos.push(required);
+  }
+  for (const opt of optional) {
+    combos.push([...required, opt]);
+  }
+  if (optional.length >= 2) {
+    combos.push([...required, ...optional]);
+  }
+  if (combos.length === 0) {
+    combos.push(schema.roles.slice());
+  }
+  return combos;
+}
+function buildTrainingPair(schema, roles, language, domain, id) {
+  const sampledRoles = /* @__PURE__ */ new Map();
+  for (const role of roles) {
+    sampledRoles.set(role.role, sampleValue2(role));
+  }
+  const nodeRoles = /* @__PURE__ */ new Map();
+  for (const [name, sample] of sampledRoles) {
+    nodeRoles.set(name, toSemanticValue2(sample));
+  }
+  const node = createCommandNode(schema.action, nodeRoles);
+  const explicit = renderExplicit(node);
+  const jsonRoles = {};
+  for (const [name, sample] of sampledRoles) {
+    jsonRoles[name] = sample;
+  }
+  const json = { action: schema.action, roles: jsonRoles };
+  const natural = buildNaturalForm(schema, sampledRoles, language);
+  const requiredCount = schema.roles.filter((r) => r.required).length;
+  const filledRequired = roles.filter((r) => r.required).length;
+  const quality = requiredCount > 0 ? filledRequired / requiredCount : 0.8;
+  return {
+    id,
+    natural,
+    language,
+    explicit,
+    json,
+    domain,
+    action: schema.action,
+    source: "synthetic",
+    quality
+  };
+}
+function buildNaturalForm(schema, roles, language) {
+  const parts = [schema.action];
+  for (const roleSpec of schema.roles) {
+    const sample = roles.get(roleSpec.role);
+    if (!sample) continue;
+    const marker = roleSpec.markerOverride?.[language];
+    if (marker) {
+      parts.push(marker);
+    }
+    parts.push(String(sample.value));
+  }
+  return parts.join(" ");
+}
+function sampleValue2(role) {
+  const primaryType = role.expectedTypes[0] || "expression";
+  switch (primaryType) {
+    case "selector":
+      return sampleSelector2(role.role);
+    case "literal":
+      return sampleLiteral2(role.role);
+    case "reference":
+      return { type: "reference", value: "me" };
+    case "expression":
+      return sampleExpression2(role.role);
+    case "flag":
+      return { type: "flag", value: true };
+    default:
+      return { type: "literal", value: "example" };
+  }
+}
+function sampleSelector2(roleName) {
+  const selectors = {
+    patient: ".active",
+    destination: "#output",
+    source: "#input",
+    target: "#target"
+  };
+  return { type: "selector", value: selectors[roleName] || `#${roleName}` };
+}
+function sampleLiteral2(roleName) {
+  const literals = {
+    duration: "30s",
+    interval: "5s",
+    delay: "500ms",
+    timeout: "10s",
+    quantity: 5,
+    limit: 10,
+    style: "json",
+    manner: "rolling",
+    format: "html"
+  };
+  return { type: "literal", value: literals[roleName] || roleName };
+}
+function sampleExpression2(roleName) {
+  const expressions = {
+    source: "/api/data",
+    destination: "#output",
+    patient: ".active",
+    instrument: "toUpperCase",
+    condition: "age > 18",
+    style: "json",
+    duration: "5s",
+    url: "/api/users"
+  };
+  return { type: "expression", value: expressions[roleName] || `/api/${roleName}` };
+}
+function toSemanticValue2(sample) {
+  switch (sample.type) {
+    case "selector":
+      return {
+        type: "selector",
+        value: String(sample.value),
+        selectorKind: detectSelectorKind2(String(sample.value))
+      };
+    case "literal":
+      return {
+        type: "literal",
+        value: sample.value,
+        dataType: typeof sample.value === "number" ? "number" : typeof sample.value === "boolean" ? "boolean" : "string"
+      };
+    case "reference":
+      return { type: "reference", value: String(sample.value) };
+    case "expression":
+      return { type: "expression", value: String(sample.value), raw: String(sample.value) };
+    case "flag":
+      return { type: "flag", value: sample.value };
+    default:
+      return { type: "literal", value: String(sample.value), dataType: "string" };
+  }
+}
+function detectSelectorKind2(selector) {
+  if (selector.startsWith("#")) return "id";
+  if (selector.startsWith(".")) return "class";
+  if (selector.startsWith("[")) return "attribute";
+  return "complex";
+}
+
+// src/feedback/feedback-formatter.ts
+function buildFeedback(input, inputFormat, diagnostics, schemaLookup, action) {
+  const hasErrors = diagnostics.some((d) => d.severity === "error");
+  const feedbackDiagnostics = diagnostics.map((d) => toFeedbackDiagnostic(d));
+  const hints = generateHints(feedbackDiagnostics, schemaLookup, action);
+  let schemaInfo;
+  let correctedExample;
+  if (action && schemaLookup) {
+    const schema = schemaLookup.getSchema(action);
+    if (schema) {
+      schemaInfo = extractSchemaInfo(schema);
+      if (hasErrors) {
+        correctedExample = generateCorrectedExample(schema);
+      }
+    }
+  }
+  return {
+    accepted: !hasErrors,
+    input: { format: inputFormat, text: input },
+    diagnostics: feedbackDiagnostics,
+    hints,
+    ...schemaInfo && { schema: schemaInfo },
+    ...correctedExample && { correctedExample }
+  };
+}
+function toFeedbackDiagnostic(d) {
+  const fixType = classifyFixType(d);
+  return {
+    severity: d.severity,
+    code: d.code || "unknown",
+    message: d.message,
+    ...d.suggestions?.[0] && { suggestion: d.suggestions[0] },
+    ...fixType && { fixType }
+  };
+}
+function classifyFixType(d) {
+  const code = (d.code || "").toLowerCase();
+  const msg = d.message.toLowerCase();
+  if (code.includes("missing-role") || code.includes("missing_role") || msg.includes("required role") || msg.includes("missing role")) {
+    return "missing_role";
+  }
+  if (code.includes("invalid-type") || code.includes("invalid_type") || code.includes("type-mismatch") || msg.includes("invalid type") || msg.includes("expected type")) {
+    return "invalid_type";
+  }
+  if (code.includes("unknown-command") || code.includes("unknown_command") || msg.includes("unknown command") || msg.includes("not recognized") && msg.includes("command")) {
+    return "unknown_command";
+  }
+  if (code.includes("unknown-role") || code.includes("unknown_role") || msg.includes("unknown role") || msg.includes("not recognized") && msg.includes("role")) {
+    return "unknown_role";
+  }
+  if (code.includes("parse") || code.includes("syntax") || msg.includes("syntax error") || msg.includes("parse error") || msg.includes("unexpected")) {
+    return "syntax_error";
+  }
+  return void 0;
+}
+function generateHints(diagnostics, schemaLookup, action) {
+  const hints = [];
+  const schema = action && schemaLookup ? schemaLookup.getSchema(action) : void 0;
+  for (const d of diagnostics) {
+    if (d.severity !== "error") continue;
+    switch (d.fixType) {
+      case "missing_role": {
+        if (schema) {
+          const required = schema.roles.filter((r) => r.required).map((r) => `'${r.role}' (${r.description}, type: ${r.expectedTypes.join("|")})`).join(", ");
+          hints.push(`Required roles for '${action}': ${required}`);
+        } else {
+          hints.push("Check that all required roles are present.");
+        }
+        break;
+      }
+      case "unknown_command": {
+        hints.push(
+          `Command not recognized. Ensure you're using a valid command from the domain schema.`
+        );
+        break;
+      }
+      case "unknown_role": {
+        if (schema) {
+          const validRoles = schema.roles.map((r) => `'${r.role}'`).join(", ");
+          hints.push(`Valid roles for '${action}': ${validRoles}`);
+        } else {
+          hints.push("Use only roles defined in the command schema.");
+        }
+        break;
+      }
+      case "invalid_type": {
+        hints.push(
+          "Check value types: selectors start with #.[@*, strings use quotes, numbers are plain digits."
+        );
+        break;
+      }
+      case "syntax_error": {
+        hints.push("Ensure bracket syntax: [command role:value ...]. No spaces around the colon.");
+        break;
+      }
+      default: {
+        if (d.suggestion) {
+          hints.push(d.suggestion);
+        }
+      }
+    }
+  }
+  return [...new Set(hints)];
+}
+function extractSchemaInfo(schema) {
+  const requiredRoles = [];
+  const optionalRoles = [];
+  const roleDescriptions = {};
+  for (const role of schema.roles) {
+    if (role.required) {
+      requiredRoles.push(role.role);
+    } else {
+      optionalRoles.push(role.role);
+    }
+    roleDescriptions[role.role] = role.description;
+  }
+  return {
+    action: schema.action,
+    requiredRoles,
+    optionalRoles,
+    roleDescriptions
+  };
+}
+function generateCorrectedExample(schema) {
+  const roles = /* @__PURE__ */ new Map();
+  const jsonRoles = {};
+  for (const role of schema.roles) {
+    if (!role.required) continue;
+    const sample = sampleDefaultValue(role.role, role.expectedTypes[0] || "expression");
+    roles.set(role.role, toSemanticValue3(sample));
+    jsonRoles[role.role] = sample;
+  }
+  const node = createCommandNode(schema.action, roles);
+  const explicit = renderExplicit(node);
+  const json = { action: schema.action, roles: jsonRoles };
+  return { explicit, json };
+}
+function sampleDefaultValue(roleName, expectedType) {
+  switch (expectedType) {
+    case "selector":
+      return { type: "selector", value: `#${roleName}` };
+    case "expression":
+      return { type: "expression", value: `<${roleName}-value>` };
+    case "literal":
+      return { type: "literal", value: `<${roleName}-value>` };
+    case "reference":
+      return { type: "reference", value: "me" };
+    default:
+      return { type: "expression", value: `<${roleName}-value>` };
+  }
+}
+function toSemanticValue3(sample) {
+  switch (sample.type) {
+    case "selector":
+      return { type: "selector", value: sample.value, selectorKind: "id" };
+    case "expression":
+      return { type: "expression", value: sample.value, raw: sample.value };
+    case "literal":
+      return { type: "literal", value: sample.value, dataType: "string" };
+    case "reference":
+      return { type: "reference", value: sample.value };
+    default:
+      return { type: "literal", value: sample.value, dataType: "string" };
+  }
+}
+
 // src/api/domain-registry.ts
 var DomainRegistry = class {
   constructor() {
@@ -1700,6 +3001,17 @@ var DomainRegistry = class {
     }
     this.descriptors.set(descriptor.name, descriptor);
   }
+  /**
+   * Attach schemas to an already-registered domain.
+   * Useful for lazy loading schemas after initial registration.
+   */
+  setSchemas(name, schemas) {
+    const existing = this.descriptors.get(name);
+    if (!existing) {
+      throw new Error(`Domain not registered: ${name}`);
+    }
+    this.descriptors.set(name, { ...existing, schemas });
+  }
   /**
    * Get all registered domain names.
    */
@@ -1769,6 +3081,71 @@ var DomainRegistry = class {
     return this.getDSL(descriptor);
   }
   // ---------------------------------------------------------------------------
+  // LLM ↔ LSE Convenience Methods
+  // ---------------------------------------------------------------------------
+  /**
+   * Generate an LLM system prompt for a domain from its schemas.
+   * Returns null if the domain is not registered or has no schemas.
+   */
+  generatePrompt(domain, config) {
+    const descriptor = this.descriptors.get(domain);
+    if (!descriptor?.schemas || descriptor.schemas.length === 0) return null;
+    return generatePrompt({
+      domain,
+      description: descriptor.description,
+      schemas: descriptor.schemas,
+      ...config
+    });
+  }
+  /**
+   * Synthesize training data for a domain from its schemas.
+   * Returns null if the domain is not registered or has no schemas.
+   */
+  generateTrainingData(domain, config) {
+    const descriptor = this.descriptors.get(domain);
+    if (!descriptor?.schemas || descriptor.schemas.length === 0) return null;
+    return synthesizeFromSchemas(descriptor.schemas, {
+      domain,
+      ...config
+    });
+  }
+  /**
+   * Build structured feedback for a failed LSE input in a domain.
+   * Returns null if the domain is not registered or has no schemas.
+   */
+  buildFeedback(domain, input, inputFormat, diagnostics) {
+    const descriptor = this.descriptors.get(domain);
+    if (!descriptor?.schemas || descriptor.schemas.length === 0) return null;
+    const schemaLookup = this.createSchemaLookup(descriptor.schemas);
+    let action;
+    try {
+      if (inputFormat === "explicit") {
+        const node = parseExplicit(input, { schemaLookup });
+        action = node.action;
+      }
+    } catch {
+    }
+    return buildFeedback(input, inputFormat, diagnostics, schemaLookup, action);
+  }
+  /**
+   * Get schemas for a domain (if available).
+   */
+  getSchemas(domain) {
+    const descriptor = this.descriptors.get(domain);
+    if (!descriptor?.schemas) return null;
+    return descriptor.schemas;
+  }
+  /**
+   * Create a SchemaLookup from a domain's schemas.
+   */
+  createSchemaLookup(schemas) {
+    const map = /* @__PURE__ */ new Map();
+    for (const s of schemas) {
+      map.set(s.action, s);
+    }
+    return { getSchema: (action) => map.get(action) };
+  }
+  // ---------------------------------------------------------------------------
   // Private: DSL/renderer lifecycle
   // ---------------------------------------------------------------------------
   async getDSL(descriptor) {
@@ -1868,7 +3245,7 @@ function generateToolDefinitions(desc) {
       case "parse":
         tools.push({
           name: `parse_${desc.name}`,
-          description: `Parse a ${desc.description} input into a semantic representation. Supports: ${langList}.`,
+          description: `Parse a ${desc.description} input into a semantic representation (action, roles, confidence). Supports: ${langList}.`,
           inputSchema: {
             type: "object",
             properties: {
@@ -1889,7 +3266,7 @@ function generateToolDefinitions(desc) {
       case "compile":
         tools.push({
           name: `compile_${desc.name}`,
-          description: `Compile a ${desc.description} input to target code. Supports: ${langList}.`,
+          description: `Compile a ${desc.description} input to ${desc.outputDescription ?? "target code"}. Supports: ${langList}.`,
           inputSchema: {
             type: "object",
             properties: {
@@ -1910,7 +3287,7 @@ function generateToolDefinitions(desc) {
       case "validate":
         tools.push({
           name: `validate_${desc.name}`,
-          description: `Validate ${desc.description} syntax. Returns whether it parses successfully and any errors. Supports: ${langList}.`,
+          description: `Check ${desc.description} syntax for errors. Returns {valid, errors[]}. Supports: ${langList}.`,
           inputSchema: {
             type: "object",
             properties: {
@@ -1931,7 +3308,7 @@ function generateToolDefinitions(desc) {
       case "translate":
         tools.push({
           name: `translate_${desc.name}`,
-          description: `Translate ${desc.description} input between natural languages. Parses in source language and renders in target language.`,
+          description: `Translate ${desc.description} input between natural languages (requires 'from' and 'to' codes). Supports: ${langList}.`,
           inputSchema: {
             type: "object",
             properties: {
@@ -1997,9 +3374,9 @@ var CrossDomainDispatcher = class {
     if (domainNames.length === 0) return null;
     const candidates = [];
     for (const name of domainNames) {
-      const dsl = await this.registry.getDSLForDomain(name);
-      if (!dsl) continue;
       try {
+        const dsl = await this.registry.getDSLForDomain(name);
+        if (!dsl) continue;
         const { node, confidence } = dsl.parseWithConfidence(input, language);
         if (confidence >= this.minConfidence) {
           candidates.push({ domain: name, node, confidence, dsl });
@@ -2008,10 +3385,16 @@ var CrossDomainDispatcher = class {
       }
     }
     if (candidates.length === 0) return null;
-    candidates.sort((a, b) => {
-      if (b.confidence !== a.confidence) return b.confidence - a.confidence;
-      return this.getPriorityIndex(a.domain) - this.getPriorityIndex(b.domain);
-    });
+    if (this.priority.length > 0) {
+      candidates.sort((a, b) => {
+        const pa = this.getPriorityIndex(a.domain);
+        const pb = this.getPriorityIndex(b.domain);
+        if (pa !== pb) return pa - pb;
+        return b.confidence - a.confidence;
+      });
+    } else {
+      candidates.sort((a, b) => b.confidence - a.confidence);
+    }
     return candidates[0];
   }
   /**
@@ -2055,6 +3438,40 @@ var CrossDomainDispatcher = class {
     const result = detected.dsl.compile(input, language);
     return { ...result, domain: detected.domain };
   }
+  /**
+   * Compile multi-line input where each line may belong to a different domain.
+   * Detects the domain for each line and compiles it, returning per-line results.
+   * Empty lines and comment lines are skipped.
+   */
+  async compileComposite(input, language = "en") {
+    const lines = input.split("\n");
+    const statements = [];
+    const errors = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (isSkippableLine(line)) continue;
+      const trimmed = line.trim();
+      const detected = await this.detect(trimmed, language);
+      if (detected) {
+        const result = detected.dsl.compile(trimmed, language);
+        statements.push({
+          line: i + 1,
+          input: trimmed,
+          domain: detected.domain,
+          ok: result.ok,
+          code: result.code,
+          errors: result.errors
+        });
+      } else {
+        errors.push({
+          line: i + 1,
+          input: trimmed,
+          message: "No domain matched this input"
+        });
+      }
+    }
+    return { statements, errors };
+  }
   /**
    * Validate input against all domains, returning the best match.
    */