@lokascript/framework 2.3.1 → 2.5.0

package/dist/index.cjs

@@ -26,13 +26,14 @@ __export(index_exports, {
   CrossDomainDispatcher: () => CrossDomainDispatcher,
   DEFAULT_OPERATORS: () => DEFAULT_OPERATORS,
   DEFAULT_PUNCTUATION: () => DEFAULT_PUNCTUATION,
-  DEFAULT_REFERENCES: () => DEFAULT_REFERENCES,
+  DEFAULT_REFERENCES: () => import_intent2.DEFAULT_REFERENCES,
   DomainAwareScanner: () => DomainAwareScanner,
   DomainRegistry: () => DomainRegistry,
   GrammarTransformer: () => GrammarTransformer,
   IdentifierExtractor: () => IdentifierExtractor,
   InMemoryDictionary: () => InMemoryDictionary,
   InMemoryProfileProvider: () => InMemoryProfileProvider,
+  LatinExtendedIdentifierExtractor: () => LatinExtendedIdentifierExtractor,
   NullDictionary: () => NullDictionary,
   NullProfileProvider: () => NullProfileProvider,
   NumberExtractor: () => NumberExtractor,
@@ -51,44 +52,44 @@ __export(index_exports, {
   buildTablesFromProfiles: () => buildTablesFromProfiles,
   combineClassifiers: () => combineClassifiers,
   convertValue: () => convertValue,
-  createAsyncNode: () => createAsyncNode,
-  createCommandNode: () => createCommandNode,
-  createCompoundNode: () => createCompoundNode,
-  createConditionalNode: () => createConditionalNode,
-  createDiagnosticCollector: () => createDiagnosticCollector,
-  createEventHandlerNode: () => createEventHandlerNode,
-  createExpression: () => createExpression,
-  createFlag: () => createFlag,
+  createAsyncNode: () => import_intent.createAsyncNode,
+  createCommandNode: () => import_intent.createCommandNode,
+  createCompoundNode: () => import_intent.createCompoundNode,
+  createConditionalNode: () => import_intent.createConditionalNode,
+  createDiagnosticCollector: () => import_intent7.createDiagnosticCollector,
+  createEventHandlerNode: () => import_intent.createEventHandlerNode,
+  createExpression: () => import_intent.createExpression,
+  createFlag: () => import_intent.createFlag,
   createLatinCharClassifiers: () => createLatinCharClassifiers,
-  createLiteral: () => createLiteral,
-  createLoopNode: () => createLoopNode,
-  createMatchNode: () => createMatchNode,
+  createLiteral: () => import_intent.createLiteral,
+  createLoopNode: () => import_intent.createLoopNode,
+  createMatchNode: () => import_intent.createMatchNode,
   createMultiStatementParser: () => createMultiStatementParser,
   createMultilingualDSL: () => createMultilingualDSL,
   createPosition: () => createPosition,
-  createPropertyPath: () => createPropertyPath,
-  createReference: () => createReference,
+  createPropertyPath: () => import_intent.createPropertyPath,
+  createReference: () => import_intent.createReference,
   createSchemaRenderer: () => createSchemaRenderer,
-  createSelector: () => createSelector,
+  createSelector: () => import_intent.createSelector,
   createSimpleTokenizer: () => createSimpleTokenizer,
   createToken: () => createToken,
   createTokenizerContext: () => createTokenizerContext,
-  createTryNode: () => createTryNode,
+  createTryNode: () => import_intent.createTryNode,
   createUnicodeRangeClassifier: () => createUnicodeRangeClassifier,
-  defineCommand: () => defineCommand,
-  defineRole: () => defineRole,
+  defineCommand: () => import_intent6.defineCommand,
+  defineRole: () => import_intent6.defineRole,
   detectWordOrders: () => detectWordOrders,
   extractCssSelector: () => extractCssSelector,
   extractNumber: () => extractNumber,
-  extractRoleValue: () => extractRoleValue,
+  extractRoleValue: () => import_intent.extractRoleValue,
   extractStringLiteral: () => extractStringLiteral,
   extractUrl: () => extractUrl,
-  extractValue: () => extractValue,
-  filterBySeverity: () => filterBySeverity,
-  fromEnvelopeJSON: () => fromEnvelopeJSON,
-  fromError: () => fromError,
+  extractValue: () => import_intent.extractValue,
+  filterBySeverity: () => import_intent7.filterBySeverity,
+  fromEnvelopeJSON: () => import_intent5.fromEnvelopeJSON,
+  fromError: () => import_intent7.fromError,
   fromInterchangeNode: () => fromInterchangeNode,
-  fromProtocolJSON: () => fromProtocolJSON,
+  fromProtocolJSON: () => import_intent5.fromProtocolJSON,
   generateExamples: () => generateExamples,
   generatePattern: () => generatePattern,
   generatePatternVariants: () => generatePatternVariants,
@@ -97,6 +98,8 @@ __export(index_exports, {
   getAllPossessiveKeywords: () => getAllPossessiveKeywords,
   getDefaultExtractors: () => getDefaultExtractors,
   getPossessiveReference: () => getPossessiveReference,
+  getRoleSpec: () => import_intent6.getRoleSpec,
+  getRoleValue: () => import_intent.getRoleValue,
   insertMarkers: () => insertMarkers,
   isAsciiIdentifierChar: () => isAsciiIdentifierChar,
   isAsciiLetter: () => isAsciiLetter,
@@ -104,12 +107,12 @@ __export(index_exports, {
   isCSSPropertyRef: () => isCSSPropertyRef,
   isCSSSelector: () => isCSSSelector,
   isClassName: () => isClassName,
-  isCompoundSyntax: () => isCompoundSyntax,
+  isCompoundSyntax: () => import_intent3.isCompoundSyntax,
   isContextAwareExtractor: () => isContextAwareExtractor,
   isDigit: () => isDigit,
-  isDocumentSyntax: () => isDocumentSyntax,
-  isEnvelope: () => isEnvelope,
-  isExplicitSyntax: () => isExplicitSyntax,
+  isDocumentSyntax: () => import_intent3.isDocumentSyntax,
+  isEnvelope: () => import_intent5.isEnvelope,
+  isExplicitSyntax: () => import_intent3.isExplicitSyntax,
   isIdSelector: () => isIdSelector,
   isNumericValue: () => isNumericValue,
   isPossessiveKeyword: () => isPossessiveKeyword,
@@ -119,7 +122,7 @@ __export(index_exports, {
   isSelectorStart: () => isSelectorStart,
   isTypeCompatible: () => isTypeCompatible,
   isUrlStart: () => isUrlStart,
-  isValidReference: () => isValidReference2,
+  isValidReference: () => import_intent2.isValidReference,
   isVariableRef: () => isVariableRef,
   isWhitespace: () => isWhitespace,
   joinTokens: () => joinTokens,
@@ -131,25 +134,25 @@ __export(index_exports, {
   needsDisambiguation: () => needsDisambiguation,
   noChange: () => noChange,
   normalized: () => normalized,
-  parseCompound: () => parseCompound,
-  parseDocument: () => parseDocument,
-  parseExplicit: () => parseExplicit,
+  parseCompound: () => import_intent3.parseCompound,
+  parseDocument: () => import_intent3.parseDocument,
+  parseExplicit: () => import_intent3.parseExplicit,
   parseJSONL: () => parseJSONL,
   patternMatcher: () => patternMatcher,
   registryToAOTBackends: () => registryToAOTBackends,
-  renderDocument: () => renderDocument,
-  renderExplicit: () => renderExplicit,
+  renderDocument: () => import_intent4.renderDocument,
+  renderExplicit: () => import_intent4.renderExplicit,
   renderExpr: () => renderExpr,
   reorderRoles: () => reorderRoles,
   semanticNodeToJSON: () => semanticNodeToJSON,
   semanticNodeToRuntimeAST: () => semanticNodeToRuntimeAST,
   semanticValueToAST: () => semanticValueToAST,
   synthesizeFromSchemas: () => synthesizeFromSchemas,
-  toEnvelopeJSON: () => toEnvelopeJSON,
+  toEnvelopeJSON: () => import_intent5.toEnvelopeJSON,
   toJSONL: () => toJSONL,
   toJSONLRow: () => toJSONLRow,
-  toProtocolJSON: () => toProtocolJSON,
-  validateProtocolJSON: () => validateProtocolJSON,
+  toProtocolJSON: () => import_intent5.toProtocolJSON,
+  validateProtocolJSON: () => import_intent5.validateProtocolJSON,
   validateSemanticJSON: () => validateSemanticJSON,
   validateValueType: () => validateValueType,
   withDefaultExtractors: () => withDefaultExtractors
@@ -157,134 +160,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/core/types.ts
-function createLiteral(value, dataType) {
-  return dataType ? { type: "literal", value, dataType } : { type: "literal", value };
-}
-function createSelector(value, selectorKind) {
-  return selectorKind ? { type: "selector", value, selectorKind } : { type: "selector", value };
-}
-function createReference(value) {
-  return { type: "reference", value };
-}
-function createPropertyPath(object, property) {
-  return { type: "property-path", object, property };
-}
-function createExpression(raw) {
-  return { type: "expression", raw };
-}
-function 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 createCompoundNode(statements, chainType = "sequential", metadata) {
-  const base = {
-    kind: "compound",
-    action: "compound",
-    roles: /* @__PURE__ */ new Map(),
-    statements,
-    chainType
-  };
-  return metadata ? { ...base, metadata } : base;
-}
-function extractValue(value) {
-  if (value.type === "flag") return value.name;
-  if ("raw" in value && value.raw !== void 0) return String(value.raw);
-  if ("value" in value && value.value !== void 0) return String(value.value);
-  if (value.type === "property-path") return `${extractValue(value.object)}.${value.property}`;
-  return "";
-}
-function extractRoleValue(node, role) {
-  const value = node.roles.get(role);
-  if (!value) return "";
-  return extractValue(value);
-}
-function createLoopNode(action, roles, loopVariant, body, loopVariable, indexVariable, metadata) {
-  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
-  const base = {
-    kind: "loop",
-    action,
-    roles: rolesMap,
-    loopVariant,
-    body
-  };
-  return {
-    ...base,
-    ...loopVariable && { loopVariable },
-    ...indexVariable && { indexVariable },
-    ...metadata && { metadata }
-  };
-}
-function createTryNode(body, catchBranch, finallyBranch, metadata) {
-  return {
-    kind: "command",
-    action: "try",
-    roles: /* @__PURE__ */ new Map(),
-    body,
-    ...catchBranch && catchBranch.length > 0 ? { catchBranch } : {},
-    ...finallyBranch && finallyBranch.length > 0 ? { finallyBranch } : {},
-    ...metadata ? { metadata } : {}
-  };
-}
-function createAsyncNode(variant, asyncBody, metadata) {
-  return {
-    kind: "command",
-    action: variant,
-    roles: /* @__PURE__ */ new Map(),
-    asyncVariant: variant,
-    asyncBody,
-    ...metadata ? { metadata } : {}
-  };
-}
-function createMatchNode(roles, arms, defaultArm, metadata) {
-  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
-  return {
-    kind: "command",
-    action: "match",
-    roles: rolesMap,
-    arms,
-    ...defaultArm && defaultArm.length > 0 ? { defaultArm } : {},
-    ...metadata ? { metadata } : {}
-  };
-}
+var import_intent = require("@lokascript/intent");
 
 // src/core/logger.ts
 var DebugLogger = class {
@@ -869,7 +745,7 @@ var _PatternMatcher = class _PatternMatcher {
         chainedProps += nextPeek.value;
         tokens.advance();
       }
-      return createPropertyPath(createReference(baseRef), chainedProps);
+      return (0, import_intent.createPropertyPath)((0, import_intent.createReference)(baseRef), chainedProps);
     }
     tokens.reset(mark);
     return null;
@@ -1068,7 +944,7 @@ var _PatternMatcher = class _PatternMatcher {
       return null;
     }
     tokens.advance();
-    return createPropertyPath(createSelector(token.value), propertyToken.value);
+    return (0, import_intent.createPropertyPath)((0, import_intent.createSelector)(token.value), propertyToken.value);
   }
   /**
    * Try to match a selector + property expression like "#output.innerText".
@@ -1099,7 +975,7 @@ var _PatternMatcher = class _PatternMatcher {
     }
     tokens.advance();
     const propertyName = propertyToken.value.slice(1);
-    return createPropertyPath(createSelector(token.value), propertyName);
+    return (0, import_intent.createPropertyPath)((0, import_intent.createSelector)(token.value), propertyName);
   }
   /**
    * Match a group pattern token (optional sequence).
@@ -1230,27 +1106,27 @@ var _PatternMatcher = class _PatternMatcher {
   tokenToSemanticValue(token) {
     switch (token.kind) {
       case "selector":
-        return createSelector(token.value);
+        return (0, import_intent.createSelector)(token.value);
       case "literal":
         return this.parseLiteralValue(token.value);
       case "keyword":
         const tokenValue = token.normalized || token.value;
         const lower = this.safeToLowerCase(tokenValue);
         if (isValidReference(lower)) {
-          return createReference(lower);
+          return (0, import_intent.createReference)(lower);
         }
-        return createLiteral(token.normalized || token.value);
+        return (0, import_intent.createLiteral)(token.normalized || token.value);
       case "identifier":
         if (typeof token.value === "string" && token.value.startsWith(":")) {
-          return createReference(token.value);
+          return (0, import_intent.createReference)(token.value);
         }
         const identLower = this.safeToLowerCase(token.value);
         if (isValidReference(identLower)) {
-          return createReference(identLower);
+          return (0, import_intent.createReference)(identLower);
         }
         return { type: "expression", raw: token.value };
       case "url":
-        return createLiteral(token.value, "string");
+        return (0, import_intent.createLiteral)(token.value, "string");
       default:
         return null;
     }
@@ -1261,24 +1137,24 @@ var _PatternMatcher = class _PatternMatcher {
   parseLiteralValue(value) {
     if (value.startsWith('"') || value.startsWith("'") || value.startsWith("`") || value.startsWith("\u300C")) {
       const inner = value.slice(1, -1);
-      return createLiteral(inner, "string");
+      return (0, import_intent.createLiteral)(inner, "string");
     }
-    if (value === "true") return createLiteral(true, "boolean");
-    if (value === "false") return createLiteral(false, "boolean");
+    if (value === "true") return (0, import_intent.createLiteral)(true, "boolean");
+    if (value === "false") return (0, import_intent.createLiteral)(false, "boolean");
     const durationMatch = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
     if (durationMatch) {
       const num2 = parseFloat(durationMatch[1]);
       const unit = durationMatch[2];
       if (unit) {
-        return createLiteral(value, "duration");
+        return (0, import_intent.createLiteral)(value, "duration");
       }
-      return createLiteral(num2, "number");
+      return (0, import_intent.createLiteral)(num2, "number");
     }
     const num = parseFloat(value);
     if (!isNaN(num)) {
-      return createLiteral(num, "number");
+      return (0, import_intent.createLiteral)(num, "number");
     }
-    return createLiteral(value, "string");
+    return (0, import_intent.createLiteral)(value, "string");
   }
   /**
    * Apply extraction rules to fill in static values and defaults for missing roles.
@@ -2132,6 +2008,22 @@ var UnicodeIdentifierExtractor = class {
     return length > 0 ? { value: input.substring(position, position + length), length } : null;
   }
 };
+var LatinExtendedIdentifierExtractor = class {
+  constructor() {
+    this.name = "latin-extended-identifier";
+  }
+  canExtract(input, position) {
+    return /\p{L}/u.test(input[position]);
+  }
+  extract(input, position) {
+    let end = position;
+    while (end < input.length && /[\p{L}\p{N}_-]/u.test(input[end])) {
+      end++;
+    }
+    if (end === position) return null;
+    return { value: input.slice(position, end), length: end - position };
+  }
+};
 var WhitespaceExtractor = class {
   constructor() {
     this.name = "whitespace";
@@ -2168,621 +2060,13 @@ function createTokenizerContext(tokenizer) {
 }
 
 // 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);
-}
+var import_intent2 = require("@lokascript/intent");
 
 // 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("]");
-}
-var CHAIN_KEYWORDS = /* @__PURE__ */ new Set(["then", "and", "async", "sequential"]);
-function splitCompoundSegments(input) {
-  const segments = [];
-  let chainType = null;
-  let current = "";
-  let bracketDepth = 0;
-  let inString = false;
-  let stringChar = "";
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    if (inString) {
-      current += char;
-      if (char === stringChar && input[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;
-      if (bracketDepth === 0) {
-        const rest = input.slice(i + 1);
-        const pipeMatch = rest.match(/^\s*\|>\s*/);
-        if (pipeMatch) {
-          segments.push(current.trim());
-          current = "";
-          chainType ?? (chainType = "pipe");
-          i += pipeMatch[0].length;
-          continue;
-        }
-        const keywordMatch = rest.match(/^\s+(then|and|async|sequential)\s+/);
-        if (keywordMatch && CHAIN_KEYWORDS.has(keywordMatch[1])) {
-          segments.push(current.trim());
-          current = "";
-          chainType ?? (chainType = keywordMatch[1]);
-          i += keywordMatch[0].length;
-          continue;
-        }
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (current.trim()) {
-    segments.push(current.trim());
-  }
-  return { segments, chainType };
-}
-function parseCompound(input, options) {
-  const trimmed = input.trim();
-  const { annotations, remainder } = extractAnnotations(trimmed);
-  const { segments, chainType } = splitCompoundSegments(remainder);
-  let node;
-  if (segments.length <= 1) {
-    node = parseExplicit(segments[0] || remainder, options);
-  } else {
-    const statements = segments.map((seg) => parseExplicit(seg, options));
-    node = createCompoundNode(statements, chainType ?? "sequential");
-  }
-  if (annotations.length > 0) {
-    return { ...node, annotations };
-  }
-  return node;
-}
-function extractAnnotations(input) {
-  const annotations = [];
-  let pos = 0;
-  while (pos < input.length) {
-    while (pos < input.length && (input[pos] === " " || input[pos] === "	")) {
-      pos++;
-    }
-    if (pos >= input.length || input[pos] !== "@") {
-      break;
-    }
-    pos++;
-    const nameStart = pos;
-    while (pos < input.length && /[A-Za-z0-9\-_]/.test(input[pos])) {
-      pos++;
-    }
-    const name = input.slice(nameStart, pos);
-    if (!name) break;
-    let value;
-    if (pos < input.length && input[pos] === "(") {
-      pos++;
-      const valueStart = pos;
-      if (pos < input.length && (input[pos] === '"' || input[pos] === "'")) {
-        const quote = input[pos];
-        pos++;
-        while (pos < input.length && input[pos] !== quote) {
-          if (input[pos] === "\\") pos++;
-          pos++;
-        }
-        pos++;
-        value = input.slice(valueStart + 1, pos - 1);
-      } else {
-        while (pos < input.length && input[pos] !== ")") {
-          pos++;
-        }
-        value = input.slice(valueStart, pos);
-      }
-      if (pos < input.length && input[pos] === ")") {
-        pos++;
-      }
-    }
-    annotations.push(value !== void 0 ? { name, value } : { name });
-  }
-  return { annotations, remainder: input.slice(pos).trim() };
-}
-var VERSION_HEADER_RE = /^#!lse\s+(\d+\.\d+(?:\.\d+)?)\s*$/;
-function parseDocument(input, options) {
-  const lines = input.split("\n");
-  let lseVersion = "1.0";
-  const nodes = [];
-  let startLine = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
-    if (!trimmed) continue;
-    const versionMatch = trimmed.match(VERSION_HEADER_RE);
-    if (versionMatch) {
-      lseVersion = versionMatch[1];
-      startLine = i + 1;
-    }
-    break;
-  }
-  for (let i = startLine; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
-    if (!trimmed) continue;
-    if (trimmed.startsWith("//") || trimmed.startsWith("#") && !trimmed.startsWith("#!")) {
-      continue;
-    }
-    nodes.push(parseCompound(trimmed, options));
-  }
-  return { lseVersion, nodes };
-}
-function isCompoundSyntax(input) {
-  const { segments } = splitCompoundSegments(input.trim());
-  return segments.length > 1;
-}
-function isDocumentSyntax(input) {
-  const trimmed = input.trim();
-  if (trimmed.includes("\n")) return true;
-  if (VERSION_HEADER_RE.test(trimmed)) return true;
-  if (trimmed.startsWith("//") || trimmed.startsWith("#") && !trimmed.startsWith("#!")) {
-    return true;
-  }
-  return false;
-}
-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;
-}
+var import_intent3 = require("@lokascript/intent");
 
 // 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 renderDocument(envelope) {
-  const lines = [];
-  if (envelope.lseVersion && envelope.lseVersion !== "1.0") {
-    lines.push(`#!lse ${envelope.lseVersion}`);
-  }
-  for (const node of envelope.nodes) {
-    lines.push(renderExplicit(node));
-  }
-  return lines.join("\n");
-}
-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;
-  }
-}
+var import_intent4 = require("@lokascript/intent");
 
 // src/ir/json-schema.ts
 var VALID_VALUE_TYPES = /* @__PURE__ */ new Set([
@@ -2853,11 +2137,11 @@ function jsonToSemanticNode(input) {
     }
   }
   if (input.trigger) {
-    roles.set("event", createLiteral(input.trigger.event, "string"));
+    roles.set("event", (0, import_intent.createLiteral)(input.trigger.event, "string"));
     const bodyRoles = new Map(roles);
     bodyRoles.delete("event");
-    const bodyNode = createCommandNode(input.action, bodyRoles);
-    return createEventHandlerNode(
+    const bodyNode = (0, import_intent.createCommandNode)(input.action, bodyRoles);
+    return (0, import_intent.createEventHandlerNode)(
       "on",
       roles,
       [bodyNode],
@@ -2865,7 +2149,7 @@ function jsonToSemanticNode(input) {
       input.trigger.modifiers ?? {}
     );
   }
-  return createCommandNode(input.action, roles, {
+  return (0, import_intent.createCommandNode)(input.action, roles, {
     sourceLanguage: "json"
   });
 }
@@ -2909,22 +2193,22 @@ function semanticNodeToJSON(node) {
 function convertJSONValue(value) {
   switch (value.type) {
     case "selector":
-      return createSelector(String(value.value), detectSelectorKind(String(value.value)));
+      return (0, import_intent.createSelector)(String(value.value), detectSelectorKind(String(value.value)));
     case "literal":
-      return createLiteral(
+      return (0, import_intent.createLiteral)(
         value.value,
         typeof value.value === "number" ? "number" : typeof value.value === "boolean" ? "boolean" : "string"
       );
     case "reference":
-      return createReference(String(value.value));
+      return (0, import_intent.createReference)(String(value.value));
     case "expression":
-      return createExpression(String(value.value));
+      return (0, import_intent.createExpression)(String(value.value));
     case "property-path":
-      return createExpression(String(value.value));
+      return (0, import_intent.createExpression)(String(value.value));
     case "flag":
-      return createFlag(String(value.value), true);
+      return (0, import_intent.createFlag)(String(value.value), true);
     default:
-      return createLiteral(String(value.value), "string");
+      return (0, import_intent.createLiteral)(String(value.value), "string");
   }
 }
 function semanticValueToJSON(value) {
@@ -2954,532 +2238,12 @@ function detectSelectorKind(selector) {
 }
 
 // src/ir/protocol-json.ts
-function toProtocolJSON(node) {
-  const roles = rolesToProtocol(node.roles);
-  let result;
-  switch (node.kind) {
-    case "command": {
-      const cmd = node;
-      result = { kind: "command", action: node.action, roles };
-      if (cmd.body && cmd.body.length > 0) {
-        result.body = cmd.body.map(toProtocolJSON);
-      }
-      if (cmd.catchBranch && cmd.catchBranch.length > 0) {
-        result.catchBranch = cmd.catchBranch.map(toProtocolJSON);
-      }
-      if (cmd.finallyBranch && cmd.finallyBranch.length > 0) {
-        result.finallyBranch = cmd.finallyBranch.map(toProtocolJSON);
-      }
-      if (cmd.asyncVariant) {
-        result.asyncVariant = cmd.asyncVariant;
-      }
-      if (cmd.asyncBody && cmd.asyncBody.length > 0) {
-        result.asyncBody = cmd.asyncBody.map(toProtocolJSON);
-      }
-      if (cmd.arms && cmd.arms.length > 0) {
-        result.arms = cmd.arms.map((arm) => ({
-          pattern: valueToProtocol(arm.pattern),
-          body: arm.body.map(toProtocolJSON)
-        }));
-      }
-      if (cmd.defaultArm && cmd.defaultArm.length > 0) {
-        result.defaultArm = cmd.defaultArm.map(toProtocolJSON);
-      }
-      break;
-    }
-    case "event-handler": {
-      const eh = node;
-      result = {
-        kind: "event-handler",
-        action: node.action,
-        roles,
-        body: eh.body.map(toProtocolJSON)
-      };
-      break;
-    }
-    case "compound": {
-      const c = node;
-      result = {
-        kind: "compound",
-        action: "compound",
-        statements: c.statements.map(toProtocolJSON),
-        chainType: c.chainType
-      };
-      break;
-    }
-    case "conditional": {
-      const cond = node;
-      result = { kind: "command", action: node.action, roles };
-      result.thenBranch = cond.thenBranch.map(toProtocolJSON);
-      if (cond.elseBranch && cond.elseBranch.length > 0) {
-        result.elseBranch = cond.elseBranch.map(toProtocolJSON);
-      }
-      break;
-    }
-    case "loop": {
-      const loop = node;
-      result = { kind: "command", action: node.action, roles };
-      result.loopVariant = loop.loopVariant;
-      result.loopBody = loop.body.map(toProtocolJSON);
-      if (loop.loopVariable) result.loopVariable = loop.loopVariable;
-      if (loop.indexVariable) result.indexVariable = loop.indexVariable;
-      break;
-    }
-  }
-  if (node.annotations && node.annotations.length > 0) {
-    result.annotations = node.annotations.map(
-      (a) => a.value !== void 0 ? { name: a.name, value: a.value } : { name: a.name }
-    );
-  }
-  if (node.diagnostics && node.diagnostics.length > 0) {
-    result.diagnostics = node.diagnostics.map((d) => {
-      const json = {
-        level: d.severity,
-        message: d.message
-      };
-      if (d.code) json.code = d.code;
-      if (d.source) json.source = d.source;
-      if (d.suggestions && d.suggestions.length > 0) json.suggestions = [...d.suggestions];
-      return json;
-    });
-  }
-  return result;
-}
-function rolesToProtocol(roles) {
-  const result = {};
-  for (const [role, value] of roles) {
-    result[role] = valueToProtocol(value);
-  }
-  return result;
-}
-function valueToProtocol(value) {
-  switch (value.type) {
-    case "selector": {
-      const PROTOCOL_SELECTOR_KINDS = /* @__PURE__ */ new Set([
-        "id",
-        "class",
-        "attribute",
-        "element",
-        "complex"
-      ]);
-      const sk = "selectorKind" in value ? value.selectorKind : void 0;
-      const sv = { type: "selector", value: value.value };
-      if (sk && PROTOCOL_SELECTOR_KINDS.has(sk)) {
-        sv.selectorKind = sk;
-      }
-      return sv;
-    }
-    case "literal":
-      return value.dataType ? { type: "literal", value: value.value, dataType: value.dataType } : { type: "literal", value: value.value };
-    case "reference":
-      return { type: "reference", value: value.value };
-    case "expression":
-      return { type: "expression", raw: value.raw };
-    case "property-path":
-      return { type: "expression", raw: extractValue(value) };
-    case "flag":
-      return { type: "flag", name: value.name, enabled: value.enabled };
-  }
-}
-function fromProtocolJSON(json) {
-  const roles = new Map(
-    Object.entries(json.roles ?? {}).map(([role, val]) => [role, valueFromProtocol(val)])
-  );
-  const annotations = json.annotations?.map(
-    (a) => a.value !== void 0 ? { name: a.name, value: a.value } : { name: a.name }
-  );
-  const diagnostics = json.diagnostics?.map((d) => ({
-    severity: d.level,
-    message: d.message,
-    ...d.code ? { code: d.code } : {},
-    ...d.source ? { source: d.source } : {},
-    ...d.suggestions && d.suggestions.length > 0 ? { suggestions: d.suggestions } : {}
-  }));
-  if (json.trigger) {
-    const eventName = json.trigger.event;
-    roles.set("event", createLiteral(eventName, "string"));
-    const bodyRoles = new Map(roles);
-    bodyRoles.delete("event");
-    const bodyNode = createCommandNode(json.action, bodyRoles);
-    const node2 = createEventHandlerNode(
-      "on",
-      roles,
-      [bodyNode],
-      { sourceLanguage: "json" },
-      json.trigger.modifiers ?? {}
-    );
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  const kind = json.kind ?? "command";
-  if (kind === "event-handler") {
-    const body = (json.body ?? []).map(fromProtocolJSON);
-    const node2 = createEventHandlerNode(json.action, roles, body);
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  if (kind === "compound") {
-    const statements = (json.statements ?? []).map(fromProtocolJSON);
-    const node2 = createCompoundNode(
-      statements,
-      json.chainType ?? "sequential"
-    );
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  if (json.thenBranch && json.thenBranch.length > 0) {
-    const thenBranch = json.thenBranch.map(fromProtocolJSON);
-    const elseBranch = json.elseBranch ? json.elseBranch.map(fromProtocolJSON) : void 0;
-    const node2 = createConditionalNode(json.action, roles, thenBranch, elseBranch);
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  if (json.loopVariant) {
-    const loopBody = (json.loopBody ?? []).map(fromProtocolJSON);
-    const node2 = createLoopNode(
-      json.action,
-      roles,
-      json.loopVariant,
-      loopBody,
-      json.loopVariable,
-      json.indexVariable
-    );
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  if (json.catchBranch || json.finallyBranch) {
-    const body = (json.body ?? []).map(fromProtocolJSON);
-    const catchBranch = json.catchBranch ? json.catchBranch.map(fromProtocolJSON) : void 0;
-    const finallyBranch = json.finallyBranch ? json.finallyBranch.map(fromProtocolJSON) : void 0;
-    const node2 = createTryNode(body, catchBranch, finallyBranch);
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  if (json.asyncVariant) {
-    const asyncBody = (json.asyncBody ?? []).map(fromProtocolJSON);
-    const node2 = createAsyncNode(json.asyncVariant, asyncBody);
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  if (json.arms && json.arms.length > 0) {
-    const arms = json.arms.map((arm) => ({
-      pattern: valueFromProtocol(arm.pattern),
-      body: arm.body.map(fromProtocolJSON)
-    }));
-    const defaultArm = json.defaultArm ? json.defaultArm.map(fromProtocolJSON) : void 0;
-    const node2 = createMatchNode(roles, arms, defaultArm);
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  if (json.body && json.body.length > 0 && kind === "command") {
-    const body = json.body.map(fromProtocolJSON);
-    const node2 = createTryNode(body);
-    return applyV12Metadata(node2, annotations, diagnostics);
-  }
-  const node = createCommandNode(json.action, roles);
-  return applyV12Metadata(node, annotations, diagnostics);
-}
-function applyV12Metadata(node, annotations, diagnostics) {
-  if ((!annotations || annotations.length === 0) && (!diagnostics || diagnostics.length === 0)) {
-    return node;
-  }
-  return {
-    ...node,
-    ...annotations && annotations.length > 0 ? { annotations } : {},
-    ...diagnostics && diagnostics.length > 0 ? { diagnostics } : {}
-  };
-}
-function valueFromProtocol(value) {
-  switch (value.type) {
-    case "selector":
-      return createSelector(String(value.value ?? ""), value.selectorKind);
-    case "literal":
-      return createLiteral(
-        value.value !== void 0 ? value.value : "",
-        value.dataType
-      );
-    case "reference":
-      return createReference(String(value.value ?? ""));
-    case "expression":
-      return createExpression(value.raw ?? String(value.value ?? ""));
-    case "flag":
-      return createFlag(
-        value.name ?? String(value.value ?? ""),
-        value.enabled ?? (typeof value.value === "boolean" ? value.value : true)
-      );
-    case "property-path":
-      return createExpression(String(value.value ?? value.raw ?? ""));
-  }
-}
-function toEnvelopeJSON(envelope) {
-  const result = {
-    lseVersion: envelope.lseVersion,
-    nodes: envelope.nodes.map(toProtocolJSON)
-  };
-  if (envelope.features && envelope.features.length > 0) {
-    result.features = [...envelope.features];
-  }
-  return result;
-}
-function fromEnvelopeJSON(json) {
-  return {
-    lseVersion: json.lseVersion,
-    ...json.features && json.features.length > 0 ? { features: json.features } : {},
-    nodes: json.nodes.map(fromProtocolJSON)
-  };
-}
-function isEnvelope(json) {
-  return typeof json === "object" && json !== null && "lseVersion" in json && "nodes" in json && Array.isArray(json.nodes);
-}
-var VALID_KINDS = /* @__PURE__ */ new Set(["command", "event-handler", "compound"]);
-var VALID_VALUE_TYPES2 = /* @__PURE__ */ new Set([
-  "selector",
-  "literal",
-  "reference",
-  "expression",
-  "property-path",
-  "flag"
-]);
-var VALID_CHAIN_TYPES = /* @__PURE__ */ new Set(["then", "and", "async", "sequential", "pipe"]);
-var VALID_ASYNC_VARIANTS = /* @__PURE__ */ new Set(["all", "race"]);
-var VALID_DIAGNOSTIC_LEVELS = /* @__PURE__ */ new Set(["error", "warning", "info"]);
-function validateProtocolJSON(json) {
-  const diagnostics = [];
-  if (typeof json !== "object" || json === null) {
-    return [{ severity: "error", code: "INVALID_ROOT", message: "Root must be a JSON object" }];
-  }
-  const node = json;
-  const kind = "kind" in node ? String(node.kind) : "command";
-  if ("kind" in node && !VALID_KINDS.has(kind)) {
-    diagnostics.push({
-      severity: "error",
-      code: "INVALID_KIND",
-      message: `Invalid kind "${node.kind}". Must be one of: command, event-handler, compound`
-    });
-  }
-  if (!("action" in node)) {
-    diagnostics.push({
-      severity: "error",
-      code: "MISSING_ACTION",
-      message: "Missing required field: action"
-    });
-  } else if (typeof node.action !== "string" || node.action.length === 0) {
-    diagnostics.push({
-      severity: "error",
-      code: "INVALID_ACTION",
-      message: "action must be a non-empty string"
-    });
-  }
-  if (!("roles" in node) && kind !== "compound") {
-    diagnostics.push({
-      severity: "error",
-      code: "MISSING_ROLES",
-      message: "Missing required field: roles"
-    });
-  } else if ("roles" in node && (typeof node.roles !== "object" || node.roles === null || Array.isArray(node.roles))) {
-    diagnostics.push({
-      severity: "error",
-      code: "INVALID_ROLES",
-      message: "roles must be a plain object"
-    });
-  } else if ("roles" in node && node.roles) {
-    for (const [role, value] of Object.entries(node.roles)) {
-      if (typeof value !== "object" || value === null) {
-        diagnostics.push({
-          severity: "error",
-          code: "INVALID_ROLE_VALUE",
-          message: `Role "${role}" value must be an object`
-        });
-        continue;
-      }
-      const v = value;
-      if (!("type" in v) || !VALID_VALUE_TYPES2.has(String(v.type))) {
-        diagnostics.push({
-          severity: "error",
-          code: "INVALID_VALUE_TYPE",
-          message: `Role "${role}" has invalid type "${v.type}"`
-        });
-      }
-      if (v.type === "flag") {
-        const hasName = typeof v.name === "string";
-        const hasEnabled = typeof v.enabled === "boolean";
-        const hasValue = "value" in v;
-        if (!hasName && !hasValue) {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_FLAG_NAME",
-            message: `Flag role "${role}" missing required field: name (or value)`
-          });
-        }
-        if (!hasEnabled && !hasValue) {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_FLAG_ENABLED",
-            message: `Flag role "${role}" missing required field: enabled (or value)`
-          });
-        }
-      }
-      if (v.type === "expression" && typeof v.raw !== "string" && !("value" in v)) {
-        diagnostics.push({
-          severity: "error",
-          code: "MISSING_EXPRESSION_RAW",
-          message: `Expression role "${role}" missing required field: raw (or value)`
-        });
-      }
-    }
-  }
-  if ("trigger" in node && node.trigger) {
-    const trigger = node.trigger;
-    if (typeof trigger !== "object" || trigger === null) {
-      diagnostics.push({
-        severity: "error",
-        code: "INVALID_TRIGGER",
-        message: "trigger must be an object"
-      });
-    } else if (!trigger.event || typeof trigger.event !== "string") {
-      diagnostics.push({
-        severity: "error",
-        code: "INVALID_TRIGGER",
-        message: "trigger.event is required and must be a non-empty string"
-      });
-    }
-  }
-  if (kind === "event-handler" && !("trigger" in node)) {
-    if (!("body" in node) || !Array.isArray(node.body)) {
-      diagnostics.push({
-        severity: "error",
-        code: "MISSING_BODY",
-        message: "event-handler node requires a body array"
-      });
-    }
-  }
-  if (kind === "compound") {
-    if (!("statements" in node) || !Array.isArray(node.statements)) {
-      diagnostics.push({
-        severity: "error",
-        code: "MISSING_STATEMENTS",
-        message: "compound node requires a statements array"
-      });
-    }
-    if ("chainType" in node && !VALID_CHAIN_TYPES.has(String(node.chainType))) {
-      diagnostics.push({
-        severity: "error",
-        code: "INVALID_CHAIN_TYPE",
-        message: `Invalid chainType "${node.chainType}". Must be one of: then, and, async, sequential, pipe`
-      });
-    }
-  }
-  if ("diagnostics" in node) {
-    if (!Array.isArray(node.diagnostics)) {
-      diagnostics.push({
-        severity: "error",
-        code: "INVALID_DIAGNOSTICS",
-        message: "diagnostics must be an array"
-      });
-    } else {
-      for (let i = 0; i < node.diagnostics.length; i++) {
-        const d = node.diagnostics[i];
-        if (!d || typeof d !== "object") {
-          diagnostics.push({
-            severity: "error",
-            code: "INVALID_DIAGNOSTIC_ENTRY",
-            message: `diagnostics[${i}] must be an object`
-          });
-          continue;
-        }
-        if (!VALID_DIAGNOSTIC_LEVELS.has(String(d.level))) {
-          diagnostics.push({
-            severity: "error",
-            code: "INVALID_DIAGNOSTIC_LEVEL",
-            message: `diagnostics[${i}].level must be "error", "warning", or "info"`
-          });
-        }
-        if (typeof d.message !== "string") {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_DIAGNOSTIC_MESSAGE",
-            message: `diagnostics[${i}] missing required field: message`
-          });
-        }
-        if ("code" in d && typeof d.code !== "string") {
-          diagnostics.push({
-            severity: "warning",
-            code: "INVALID_DIAGNOSTIC_CODE",
-            message: `diagnostics[${i}].code must be a string if present`
-          });
-        }
-      }
-    }
-  }
-  if ("annotations" in node) {
-    if (!Array.isArray(node.annotations)) {
-      diagnostics.push({
-        severity: "error",
-        code: "INVALID_ANNOTATIONS",
-        message: "annotations must be an array"
-      });
-    } else {
-      for (let i = 0; i < node.annotations.length; i++) {
-        const a = node.annotations[i];
-        if (!a || typeof a !== "object") {
-          diagnostics.push({
-            severity: "error",
-            code: "INVALID_ANNOTATION_ENTRY",
-            message: `annotations[${i}] must be an object`
-          });
-          continue;
-        }
-        if (typeof a.name !== "string" || a.name.length === 0) {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_ANNOTATION_NAME",
-            message: `annotations[${i}] missing required field: name`
-          });
-        }
-      }
-    }
-  }
-  if ("asyncVariant" in node && !VALID_ASYNC_VARIANTS.has(String(node.asyncVariant))) {
-    diagnostics.push({
-      severity: "error",
-      code: "INVALID_ASYNC_VARIANT",
-      message: `Invalid asyncVariant "${node.asyncVariant}". Must be "all" or "race"`
-    });
-  }
-  if ("arms" in node) {
-    if (!Array.isArray(node.arms)) {
-      diagnostics.push({
-        severity: "error",
-        code: "INVALID_ARMS",
-        message: "arms must be an array"
-      });
-    } else {
-      for (let i = 0; i < node.arms.length; i++) {
-        const arm = node.arms[i];
-        if (!arm || typeof arm !== "object") {
-          diagnostics.push({
-            severity: "error",
-            code: "INVALID_ARM_ENTRY",
-            message: `arms[${i}] must be an object`
-          });
-          continue;
-        }
-        if (!arm.pattern || typeof arm.pattern !== "object") {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_ARM_PATTERN",
-            message: `arms[${i}] missing required field: pattern`
-          });
-        }
-        if (!Array.isArray(arm.body)) {
-          diagnostics.push({
-            severity: "error",
-            code: "MISSING_ARM_BODY",
-            message: `arms[${i}] missing required field: body (array)`
-          });
-        }
-      }
-    }
-  }
-  return diagnostics;
-}
+var import_intent5 = require("@lokascript/intent");
 
 // src/ir/from-interchange.ts
 function fromInterchangeNode(node) {
   if (!node || typeof node !== "object") {
-    return createCommandNode("unknown", {});
+    return (0, import_intent.createCommandNode)("unknown", {});
   }
   switch (node.type) {
     case "event":
@@ -3496,7 +2260,7 @@ function fromInterchangeNode(node) {
       return convertWhile(node);
     // Expression nodes — wrap as `get` command with patient role
     default:
-      return createCommandNode("get", { patient: convertValue(node) });
+      return (0, import_intent.createCommandNode)("get", { patient: convertValue(node) });
   }
 }
 function convertEvent(node) {
@@ -3504,7 +2268,7 @@ function convertEvent(node) {
   const bodyNodes = Array.isArray(node.body) ? node.body : [];
   const body = bodyNodes.map(fromInterchangeNode);
   const roles = {
-    event: createLiteral(event)
+    event: (0, import_intent.createLiteral)(event)
   };
   if (node.target && typeof node.target === "object") {
     roles.source = convertValue(node.target);
@@ -3513,12 +2277,12 @@ function convertEvent(node) {
   let eventModifiers;
   if (modifiers) {
     eventModifiers = bridgeEventModifiers(modifiers);
-    if (modifiers.prevent) roles.prevent = createLiteral(true);
-    if (modifiers.stop) roles.stop = createLiteral(true);
-    if (modifiers.passive) roles.passive = createLiteral(true);
-    if (modifiers.capture) roles.capture = createLiteral(true);
+    if (modifiers.prevent) roles.prevent = (0, import_intent.createLiteral)(true);
+    if (modifiers.stop) roles.stop = (0, import_intent.createLiteral)(true);
+    if (modifiers.passive) roles.passive = (0, import_intent.createLiteral)(true);
+    if (modifiers.capture) roles.capture = (0, import_intent.createLiteral)(true);
   }
-  return createEventHandlerNode("on", roles, body, void 0, eventModifiers);
+  return (0, import_intent.createEventHandlerNode)("on", roles, body, void 0, eventModifiers);
 }
 function convertCommand(node) {
   const name = String(node.name ?? "unknown");
@@ -3537,10 +2301,10 @@ function convertCommand(node) {
   } else {
     roles = inferRoles(name, args, modifiers, target);
   }
-  return createCommandNode(name, roles);
+  return (0, import_intent.createCommandNode)(name, roles);
 }
 function convertIf(node) {
-  const condition = node.condition && typeof node.condition === "object" ? convertValue(node.condition) : createExpression("true");
+  const condition = node.condition && typeof node.condition === "object" ? convertValue(node.condition) : (0, import_intent.createExpression)("true");
   const thenBody = Array.isArray(node.thenBranch) ? node.thenBranch : [];
   const thenBranch = thenBody.map(fromInterchangeNode);
   let elseBranch;
@@ -3551,7 +2315,7 @@ function convertIf(node) {
     elseBranch = node.elseBranch.map(fromInterchangeNode);
   }
   const roles = { condition };
-  return createConditionalNode("if", roles, thenBranch, elseBranch);
+  return (0, import_intent.createConditionalNode)("if", roles, thenBranch, elseBranch);
 }
 function chainElseIfs(branches, finalElse) {
   const [first, ...rest] = branches;
@@ -3563,7 +2327,7 @@ function chainElseIfs(branches, finalElse) {
   } else if (finalElse && finalElse.length > 0) {
     elseBranch = finalElse.map(fromInterchangeNode);
   }
-  return createConditionalNode("if", { condition }, thenBranch, elseBranch);
+  return (0, import_intent.createConditionalNode)("if", { condition }, thenBranch, elseBranch);
 }
 function convertRepeat(node) {
   const bodyNodes = Array.isArray(node.body) ? node.body : [];
@@ -3573,7 +2337,7 @@ function convertRepeat(node) {
   if (node.count !== void 0 && node.count !== null) {
     variant = "times";
     if (typeof node.count === "number") {
-      roles.quantity = createLiteral(node.count, "number");
+      roles.quantity = (0, import_intent.createLiteral)(node.count, "number");
     } else if (typeof node.count === "object") {
       roles.quantity = convertValue(node.count);
     }
@@ -3582,11 +2346,11 @@ function convertRepeat(node) {
     roles.condition = convertValue(node.whileCondition);
   } else if (typeof node.untilEvent === "string") {
     variant = "until";
-    roles.condition = createLiteral(node.untilEvent);
+    roles.condition = (0, import_intent.createLiteral)(node.untilEvent);
   } else {
     variant = "forever";
   }
-  return createLoopNode("repeat", roles, variant, body);
+  return (0, import_intent.createLoopNode)("repeat", roles, variant, body);
 }
 function convertForEach(node) {
   const bodyNodes = Array.isArray(node.body) ? node.body : [];
@@ -3597,7 +2361,7 @@ function convertForEach(node) {
   }
   const itemName = typeof node.itemName === "string" ? node.itemName : void 0;
   const indexName = typeof node.indexName === "string" ? node.indexName : void 0;
-  return createLoopNode("repeat", roles, "for", body, itemName, indexName);
+  return (0, import_intent.createLoopNode)("repeat", roles, "for", body, itemName, indexName);
 }
 function convertWhile(node) {
   const bodyNodes = Array.isArray(node.body) ? node.body : [];
@@ -3606,21 +2370,21 @@ function convertWhile(node) {
   if (node.condition && typeof node.condition === "object") {
     roles.condition = convertValue(node.condition);
   }
-  return createLoopNode("repeat", roles, "while", body);
+  return (0, import_intent.createLoopNode)("repeat", roles, "while", body);
 }
 function convertValue(node) {
   switch (node.type) {
     case "literal":
       return convertLiteral(node);
     case "selector":
-      return createSelector(String(node.value ?? ""), inferSelectorKind2(String(node.value ?? "")));
+      return (0, import_intent.createSelector)(String(node.value ?? ""), inferSelectorKind(String(node.value ?? "")));
     case "identifier":
       return convertIdentifier(node);
     case "variable":
       return convertVariable(node);
     case "possessive":
-      return createPropertyPath(
-        node.object && typeof node.object === "object" ? convertValue(node.object) : createReference("me"),
+      return (0, import_intent.createPropertyPath)(
+        node.object && typeof node.object === "object" ? convertValue(node.object) : (0, import_intent.createReference)("me"),
         String(node.property ?? "")
       );
     // Complex expressions → collapse to raw string
@@ -3629,35 +2393,35 @@ function convertValue(node) {
     case "member":
     case "call":
     case "positional":
-      return createExpression(renderExpr(node));
+      return (0, import_intent.createExpression)(renderExpr(node));
     default:
-      if ("value" in node) return createLiteral(String(node.value ?? ""));
-      return createExpression(renderExpr(node));
+      if ("value" in node) return (0, import_intent.createLiteral)(String(node.value ?? ""));
+      return (0, import_intent.createExpression)(renderExpr(node));
   }
 }
 function convertLiteral(node) {
   const value = node.value;
-  if (value === null || value === void 0) return createLiteral("null");
+  if (value === null || value === void 0) return (0, import_intent.createLiteral)("null");
   const dataType = typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : void 0;
-  return createLiteral(value, dataType);
+  return (0, import_intent.createLiteral)(value, dataType);
 }
 function convertIdentifier(node) {
   const value = String(node.value ?? "");
-  if (DEFAULT_REFERENCES.has(value)) {
-    return createReference(value);
+  if (import_intent2.DEFAULT_REFERENCES.has(value)) {
+    return (0, import_intent.createReference)(value);
   }
-  return createLiteral(value);
+  return (0, import_intent.createLiteral)(value);
 }
 function convertVariable(node) {
   const name = String(node.name ?? "");
   const scope = String(node.scope ?? "local");
   switch (scope) {
     case "element":
-      return createExpression(`:${name}`);
+      return (0, import_intent.createExpression)(`:${name}`);
     case "global":
-      return createExpression(`$${name}`);
+      return (0, import_intent.createExpression)(`$${name}`);
     default:
-      return createExpression(name);
+      return (0, import_intent.createExpression)(name);
   }
 }
 function renderExpr(node) {
@@ -3715,6 +2479,33 @@ function renderExpr(node) {
       return "";
   }
 }
+var SCROLL_MARKERS = /* @__PURE__ */ new Set([
+  "to",
+  "of",
+  "the",
+  "top",
+  "bottom",
+  "middle",
+  "center",
+  "nearest",
+  "left",
+  "right",
+  "smoothly",
+  "instantly"
+]);
+var URL_MARKERS = /* @__PURE__ */ new Set(["url"]);
+var PARTIALS_IN_MARKERS = /* @__PURE__ */ new Set(["partials", "in"]);
+function firstNonMarkerArg(args, markers) {
+  for (const a of args) {
+    if (a.type === "identifier") {
+      const ident = a;
+      const word = typeof ident.name === "string" ? ident.name : ident.value;
+      if (typeof word === "string" && markers.has(word)) continue;
+    }
+    return a;
+  }
+  return void 0;
+}
 function inferRoles(name, args, modifiers, target) {
   const roles = {};
   switch (name) {
@@ -3735,7 +2526,7 @@ function inferRoles(name, args, modifiers, target) {
           const val = modifiers[key];
           if (val && typeof val === "object" && "type" in val) {
             roles.destination = convertValue(val);
-            roles.method = createLiteral(key);
+            roles.method = (0, import_intent.createLiteral)(key);
             break;
           }
         }
@@ -3762,7 +2553,7 @@ function inferRoles(name, args, modifiers, target) {
       if (asVal && typeof asVal === "object" && "type" in asVal) {
         roles.responseType = convertValue(asVal);
       } else if (typeof asVal === "string") {
-        roles.responseType = createLiteral(asVal);
+        roles.responseType = (0, import_intent.createLiteral)(asVal);
       }
       break;
     }
@@ -3794,6 +2585,25 @@ function inferRoles(name, args, modifiers, target) {
       if (args[0]) roles.patient = convertValue(args[0]);
       break;
     }
+    // scroll [to] [position] target [smoothly|instantly]  →  destination=target
+    case "scroll": {
+      const t = firstNonMarkerArg(args, SCROLL_MARKERS);
+      if (t) roles.destination = convertValue(t);
+      break;
+    }
+    // push|replace url <X>  →  patient=X
+    case "push":
+    case "replace": {
+      const t = firstNonMarkerArg(args, URL_MARKERS);
+      if (t) roles.patient = convertValue(t);
+      break;
+    }
+    // process partials in <X>  →  patient=X
+    case "process": {
+      const t = firstNonMarkerArg(args, PARTIALS_IN_MARKERS);
+      if (t) roles.patient = convertValue(t);
+      break;
+    }
     default: {
       if (args[0]) roles.patient = convertValue(args[0]);
       if (target) roles.destination = convertValue(target);
@@ -3802,7 +2612,7 @@ function inferRoles(name, args, modifiers, target) {
   }
   return roles;
 }
-function inferSelectorKind2(value) {
+function inferSelectorKind(value) {
   if (!value) return void 0;
   if (value.startsWith("#")) return "id";
   if (value.startsWith(".")) return "class";
@@ -3812,10 +2622,10 @@ function inferSelectorKind2(value) {
   return void 0;
 }
 function inferValueFromString(value) {
-  if (DEFAULT_REFERENCES.has(value)) return createReference(value);
-  const kind = inferSelectorKind2(value);
-  if (kind) return createSelector(value, kind);
-  return createLiteral(value);
+  if (import_intent2.DEFAULT_REFERENCES.has(value)) return (0, import_intent.createReference)(value);
+  const kind = inferSelectorKind(value);
+  if (kind) return (0, import_intent.createSelector)(value, kind);
+  return (0, import_intent.createLiteral)(value);
 }
 function bridgeEventModifiers(mods) {
   const once = mods.once === true ? true : void 0;
@@ -3997,8 +2807,8 @@ var MultilingualDSLImpl = class {
     return result.node;
   }
   parseWithConfidence(input, language) {
-    if (isExplicitSyntax(input)) {
-      const node = parseExplicit(input, { schemaLookup: this.schemaLookup });
+    if ((0, import_intent3.isExplicitSyntax)(input)) {
+      const node = (0, import_intent3.parseExplicit)(input, { schemaLookup: this.schemaLookup });
       if (!this.schemaLookup.getSchema(node.action)) {
         throw new Error(`No schema for action "${node.action}" in this DSL`);
       }
@@ -4047,7 +2857,7 @@ var MultilingualDSLImpl = class {
     }
   }
   translate(input, fromLanguage, toLanguage) {
-    if (isExplicitSyntax(input)) return input;
+    if ((0, import_intent3.isExplicitSyntax)(input)) return input;
     return this.transformer.transform(input, fromLanguage, toLanguage);
   }
   compile(input, language) {
@@ -4153,8 +2963,8 @@ function generateExamples(schema, count = 2) {
     for (const [roleName, sample] of roles) {
       nodeRoles.set(roleName, toSemanticValue(sample));
     }
-    const node = createCommandNode(schema.action, nodeRoles);
-    const explicit = renderExplicit(node);
+    const node = (0, import_intent.createCommandNode)(schema.action, nodeRoles);
+    const explicit = (0, import_intent4.renderExplicit)(node);
     const jsonRoles = {};
     for (const [roleName, sample] of roles) {
       jsonRoles[roleName] = sample;
@@ -4551,8 +3361,8 @@ function buildTrainingPair(schema, roles, language, domain, id) {
   for (const [name, sample] of sampledRoles) {
     nodeRoles.set(name, toSemanticValue2(sample));
   }
-  const node = createCommandNode(schema.action, nodeRoles);
-  const explicit = renderExplicit(node);
+  const node = (0, import_intent.createCommandNode)(schema.action, nodeRoles);
+  const explicit = (0, import_intent4.renderExplicit)(node);
   const jsonRoles = {};
   for (const [name, sample] of sampledRoles) {
     jsonRoles[name] = sample;
@@ -4803,8 +3613,8 @@ function generateCorrectedExample(schema) {
     roles.set(role.role, toSemanticValue3(sample));
     jsonRoles[role.role] = sample;
   }
-  const node = createCommandNode(schema.action, roles);
-  const explicit = renderExplicit(node);
+  const node = (0, import_intent.createCommandNode)(schema.action, roles);
+  const explicit = (0, import_intent4.renderExplicit)(node);
   const json = { action: schema.action, roles: jsonRoles };
   return { explicit, json };
 }
@@ -4973,7 +3783,7 @@ var DomainRegistry = class {
     let action;
     try {
       if (inputFormat === "explicit") {
-        const node = parseExplicit(input, { schemaLookup });
+        const node = (0, import_intent3.parseExplicit)(input, { schemaLookup });
         action = node.action;
       }
     } catch {
@@ -5631,25 +4441,7 @@ async function registryToAOTBackends(registry) {
 }
 
 // src/schema/command-schema.ts
-function defineCommand(schema) {
-  return {
-    description: schema.description || `${schema.action} command`,
-    category: schema.category || "general",
-    primaryRole: schema.primaryRole || schema.roles[0]?.role || "patient",
-    ...schema,
-    action: schema.action,
-    roles: schema.roles
-  };
-}
-function defineRole(role) {
-  return {
-    description: role.description || `${role.role} role`,
-    ...role,
-    role: role.role,
-    required: role.required,
-    expectedTypes: role.expectedTypes
-  };
-}
+var import_intent6 = require("@lokascript/intent");
 
 // src/generation/renderer.ts
 function lookupKeyword(keywords, action, language) {
@@ -5713,7 +4505,7 @@ function createSchemaRenderer(schemas, profiles) {
       const isSOV = sovLanguages.has(language);
       const roleParts = [];
       for (const role of schema.roles) {
-        const value = extractRoleValue(node, role.role);
+        const value = (0, import_intent.extractRoleValue)(node, role.role);
         if (!value && !role.required) continue;
         const markerText = role.markerOverride?.[language] ?? markers[role.role]?.[language] ?? void 0;
         roleParts.push({
@@ -5742,71 +4534,7 @@ function createSchemaRenderer(schemas, profiles) {
 }
 
 // src/generation/diagnostics.ts
-function createDiagnosticCollector() {
-  const diagnostics = [];
-  function addWithSeverity(severity, message, options) {
-    const diag = {
-      message,
-      severity,
-      ...options?.code != null && { code: options.code },
-      ...options?.line != null && { line: options.line },
-      ...options?.column != null && { column: options.column },
-      ...options?.source != null && { source: options.source },
-      ...options?.suggestions != null && options.suggestions.length > 0 && { suggestions: options.suggestions }
-    };
-    diagnostics.push(diag);
-  }
-  return {
-    error(message, options) {
-      addWithSeverity("error", message, options);
-    },
-    warning(message, options) {
-      addWithSeverity("warning", message, options);
-    },
-    info(message, options) {
-      addWithSeverity("info", message, options);
-    },
-    add(diagnostic) {
-      diagnostics.push(diagnostic);
-    },
-    hasErrors() {
-      return diagnostics.some((d) => d.severity === "error");
-    },
-    getDiagnostics() {
-      return diagnostics;
-    },
-    toResult() {
-      let errors = 0;
-      let warnings = 0;
-      let infos = 0;
-      for (const d of diagnostics) {
-        if (d.severity === "error") errors++;
-        else if (d.severity === "warning") warnings++;
-        else infos++;
-      }
-      return {
-        ok: errors === 0,
-        diagnostics,
-        summary: { errors, warnings, infos }
-      };
-    }
-  };
-}
-function fromError(error, options) {
-  const message = error instanceof Error ? error.message : String(error);
-  return {
-    message,
-    severity: "error",
-    ...options?.code != null && { code: options.code },
-    ...options?.line != null && { line: options.line },
-    ...options?.column != null && { column: options.column },
-    ...options?.source != null && { source: options.source },
-    ...options?.suggestions != null && options.suggestions.length > 0 && { suggestions: options.suggestions }
-  };
-}
-function filterBySeverity(diagnostics, severity) {
-  return diagnostics.filter((d) => d.severity === severity);
-}
+var import_intent7 = require("@lokascript/intent");
 
 // src/core/tokenization/token-utils.ts
 var TokenStreamImpl = class {
@@ -7085,7 +5813,7 @@ function buildDisambiguation(input, candidates) {
   const disambiguationCandidates = sortedCandidates.map((c, i) => ({
     action: c.action,
     confidence: c.confidence,
-    explicit: renderExplicit(c.node),
+    explicit: (0, import_intent4.renderExplicit)(c.node),
     description: c.description || `${c.action} (option ${String.fromCharCode(97 + i)})`
   }));
   const optionLines = disambiguationCandidates.map(
@@ -7462,6 +6190,7 @@ function accumulateIndented(statements, config) {
   IdentifierExtractor,
   InMemoryDictionary,
   InMemoryProfileProvider,
+  LatinExtendedIdentifierExtractor,
   NullDictionary,
   NullProfileProvider,
   NumberExtractor,
@@ -7526,6 +6255,8 @@ function accumulateIndented(statements, config) {
   getAllPossessiveKeywords,
   getDefaultExtractors,
   getPossessiveReference,
+  getRoleSpec,
+  getRoleValue,
   insertMarkers,
   isAsciiIdentifierChar,
   isAsciiLetter,