@lokascript/framework 2.3.0 → 2.4.0

package/dist/index.js

@@ -1,132 +1,23 @@
 // 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 } : {}
-  };
-}
+import {
+  createLiteral,
+  createSelector,
+  createReference,
+  createPropertyPath,
+  createExpression,
+  createFlag,
+  createCommandNode,
+  createEventHandlerNode,
+  createConditionalNode,
+  createCompoundNode,
+  createLoopNode,
+  createTryNode,
+  createAsyncNode,
+  createMatchNode,
+  extractValue,
+  extractRoleValue,
+  getRoleValue
+} from "@lokascript/intent";
 
 // src/core/logger.ts
 var DebugLogger = class {
@@ -1974,6 +1865,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";
@@ -2010,621 +1917,21 @@ 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);
-}
+import { DEFAULT_REFERENCES, isValidReference as isValidReference2 } from "@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;
-}
+import {
+  STRUCTURAL_ROLES,
+  parseExplicit,
+  isExplicitSyntax,
+  parseCompound,
+  parseDocument,
+  isCompoundSyntax,
+  isDocumentSyntax
+} from "@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;
-  }
-}
+import { renderExplicit, renderDocument } from "@lokascript/intent";
 
 // src/ir/json-schema.ts
 var VALID_VALUE_TYPES = /* @__PURE__ */ new Set([
@@ -2796,527 +2103,14 @@ 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;
-}
+import {
+  toProtocolJSON,
+  fromProtocolJSON,
+  validateProtocolJSON,
+  toEnvelopeJSON,
+  fromEnvelopeJSON,
+  isEnvelope
+} from "@lokascript/intent";
 
 // src/ir/from-interchange.ts
 function fromInterchangeNode(node) {
@@ -3455,7 +2249,7 @@ function convertValue(node) {
     case "literal":
       return convertLiteral(node);
     case "selector":
-      return createSelector(String(node.value ?? ""), inferSelectorKind2(String(node.value ?? "")));
+      return createSelector(String(node.value ?? ""), inferSelectorKind(String(node.value ?? "")));
     case "identifier":
       return convertIdentifier(node);
     case "variable":
@@ -3557,6 +2351,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) {
@@ -3636,6 +2457,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);
@@ -3644,7 +2484,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";
@@ -3655,7 +2495,7 @@ function inferSelectorKind2(value) {
 }
 function inferValueFromString(value) {
   if (DEFAULT_REFERENCES.has(value)) return createReference(value);
-  const kind = inferSelectorKind2(value);
+  const kind = inferSelectorKind(value);
   if (kind) return createSelector(value, kind);
   return createLiteral(value);
 }
@@ -5473,25 +4313,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
-  };
-}
+import { defineCommand, defineRole, getRoleSpec } from "@lokascript/intent";
 
 // src/generation/renderer.ts
 function lookupKeyword(keywords, action, language) {
@@ -5584,71 +4406,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);
-}
+import { createDiagnosticCollector, fromError, filterBySeverity } from "@lokascript/intent";
 
 // src/core/tokenization/token-utils.ts
 var TokenStreamImpl = class {
@@ -7303,6 +6061,7 @@ export {
   IdentifierExtractor,
   InMemoryDictionary,
   InMemoryProfileProvider,
+  LatinExtendedIdentifierExtractor,
   NullDictionary,
   NullProfileProvider,
   NumberExtractor,
@@ -7367,6 +6126,8 @@ export {
   getAllPossessiveKeywords,
   getDefaultExtractors,
   getPossessiveReference,
+  getRoleSpec,
+  getRoleValue,
   insertMarkers,
   isAsciiIdentifierChar,
   isAsciiLetter,