@lokascript/framework 2.0.0 → 2.2.0

package/dist/ir/index.js

@@ -0,0 +1,1934 @@
+// src/ir/references.ts
+var DEFAULT_REFERENCES = /* @__PURE__ */ new Set([
+  "me",
+  "you",
+  "it",
+  "result",
+  "event",
+  "target",
+  "body"
+]);
+function isValidReference(value, referenceSet = DEFAULT_REFERENCES) {
+  return referenceSet.has(value);
+}
+
+// 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 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 } : {}
+  };
+}
+
+// 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 (isValidReference(lowerRef, referenceSet)) {
+    return createReference(lowerRef);
+  }
+  const numMatch = valueStr.match(/^(-?\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (numMatch) {
+    const num = parseFloat(numMatch[1]);
+    const suffix = numMatch[2];
+    if (suffix) {
+      return createLiteral(valueStr, "duration");
+    }
+    return createLiteral(num, "number");
+  }
+  return createLiteral(valueStr);
+}
+function findMatchingBracket(str, start) {
+  let depth = 0;
+  for (let i = start; i < str.length; i++) {
+    if (str[i] === "[") depth++;
+    else if (str[i] === "]") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return str.length - 1;
+}
+
+// src/ir/explicit-renderer.ts
+function renderExplicit(node) {
+  let result;
+  if (node.kind === "compound") {
+    const compoundNode = node;
+    const renderedStatements = compoundNode.statements.map((stmt) => renderExplicit(stmt));
+    result = renderedStatements.join(` ${compoundNode.chainType} `);
+  } else {
+    result = renderBracketCommand(node);
+  }
+  if (node.annotations && node.annotations.length > 0) {
+    const annParts = node.annotations.map(
+      (ann) => ann.value !== void 0 ? `@${ann.name}(${ann.value})` : `@${ann.name}`
+    );
+    return annParts.join(" ") + " " + result;
+  }
+  return result;
+}
+function 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;
+  }
+}
+
+// src/ir/json-schema.ts
+var VALID_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "selector",
+  "literal",
+  "reference",
+  "expression",
+  "property-path",
+  "flag"
+]);
+function validateSemanticJSON(input) {
+  const diagnostics = [];
+  if (!input.action || typeof input.action !== "string") {
+    diagnostics.push({
+      severity: "error",
+      code: "INVALID_ACTION",
+      message: 'Field "action" is required and must be a string.',
+      suggestion: 'Provide a command name like "toggle", "add", "set", etc.'
+    });
+    return diagnostics;
+  }
+  if (input.roles && typeof input.roles === "object") {
+    for (const [role, value] of Object.entries(input.roles)) {
+      if (!value || typeof value !== "object") {
+        diagnostics.push({
+          severity: "error",
+          code: "INVALID_ROLE_VALUE",
+          message: `Role "${role}" must be an object with "type" and "value" fields.`,
+          suggestion: 'Use: { "type": "selector", "value": ".active" }'
+        });
+        continue;
+      }
+      const v = value;
+      if (!VALID_VALUE_TYPES.has(v.type)) {
+        diagnostics.push({
+          severity: "error",
+          code: "INVALID_VALUE_TYPE",
+          message: `Role "${role}" has invalid type "${v.type}".`,
+          suggestion: "Valid types: selector, literal, reference, expression, property-path."
+        });
+      }
+      if (v.value === void 0 || v.value === null) {
+        diagnostics.push({
+          severity: "error",
+          code: "MISSING_VALUE",
+          message: `Role "${role}" is missing the "value" field.`
+        });
+      }
+    }
+  }
+  if (input.trigger) {
+    if (!input.trigger.event || typeof input.trigger.event !== "string") {
+      diagnostics.push({
+        severity: "error",
+        code: "INVALID_TRIGGER",
+        message: 'Trigger "event" is required and must be a string.',
+        suggestion: 'Use an event name like "click", "mouseover", "keydown".'
+      });
+    }
+  }
+  return diagnostics;
+}
+function jsonToSemanticNode(input) {
+  const roles = /* @__PURE__ */ new Map();
+  if (input.roles) {
+    for (const [role, value] of Object.entries(input.roles)) {
+      roles.set(role, convertJSONValue(value));
+    }
+  }
+  if (input.trigger) {
+    roles.set("event", createLiteral(input.trigger.event, "string"));
+    const bodyRoles = new Map(roles);
+    bodyRoles.delete("event");
+    const bodyNode = createCommandNode(input.action, bodyRoles);
+    return createEventHandlerNode(
+      "on",
+      roles,
+      [bodyNode],
+      { sourceLanguage: "json" },
+      input.trigger.modifiers ?? {}
+    );
+  }
+  return createCommandNode(input.action, roles, {
+    sourceLanguage: "json"
+  });
+}
+function semanticNodeToJSON(node) {
+  if (node.kind === "compound") {
+    const compound = node;
+    if (compound.statements.length > 0) {
+      return semanticNodeToJSON(compound.statements[0]);
+    }
+    return { action: "compound", roles: {} };
+  }
+  if (node.kind === "event-handler") {
+    const eventNode = node;
+    const bodyAction = eventNode.body?.[0]?.action ?? node.action;
+    const roles2 = {};
+    if (eventNode.body?.[0]) {
+      for (const [role, value] of eventNode.body[0].roles) {
+        roles2[role] = semanticValueToJSON(value);
+      }
+    }
+    const eventValue = node.roles.get("event");
+    const eventName = eventValue ? "value" in eventValue ? String(eventValue.value) : "raw" in eventValue ? eventValue.raw : "unknown" : "unknown";
+    const result = {
+      action: bodyAction === "on" ? eventNode.body?.[0]?.action ?? "on" : bodyAction,
+      roles: roles2,
+      trigger: {
+        event: eventName
+      }
+    };
+    if (eventNode.eventModifiers && Object.keys(eventNode.eventModifiers).length > 0) {
+      result.trigger.modifiers = eventNode.eventModifiers;
+    }
+    return result;
+  }
+  const roles = {};
+  for (const [role, value] of node.roles) {
+    roles[role] = semanticValueToJSON(value);
+  }
+  return { action: node.action, roles };
+}
+function convertJSONValue(value) {
+  switch (value.type) {
+    case "selector":
+      return createSelector(String(value.value), detectSelectorKind(String(value.value)));
+    case "literal":
+      return createLiteral(
+        value.value,
+        typeof value.value === "number" ? "number" : typeof value.value === "boolean" ? "boolean" : "string"
+      );
+    case "reference":
+      return createReference(String(value.value));
+    case "expression":
+      return createExpression(String(value.value));
+    case "property-path":
+      return createExpression(String(value.value));
+    case "flag":
+      return createFlag(String(value.value), true);
+    default:
+      return createLiteral(String(value.value), "string");
+  }
+}
+function semanticValueToJSON(value) {
+  switch (value.type) {
+    case "selector":
+      return { type: "selector", value: value.value };
+    case "literal":
+      return { type: "literal", value: value.value };
+    case "reference":
+      return { type: "reference", value: value.value };
+    case "expression":
+      return { type: "expression", value: value.raw };
+    case "property-path":
+      return {
+        type: "property-path",
+        value: `${semanticValueToJSON(value.object).value}.${value.property}`
+      };
+    case "flag":
+      return { type: "flag", value: value.enabled };
+  }
+}
+function detectSelectorKind(selector) {
+  if (selector.startsWith("#")) return "id";
+  if (selector.startsWith(".")) return "class";
+  if (selector.startsWith("[")) return "attribute";
+  return "complex";
+}
+
+// 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;
+}
+
+// src/ir/from-interchange.ts
+function fromInterchangeNode(node) {
+  if (!node || typeof node !== "object") {
+    return createCommandNode("unknown", {});
+  }
+  switch (node.type) {
+    case "event":
+      return convertEvent(node);
+    case "command":
+      return convertCommand(node);
+    case "if":
+      return convertIf(node);
+    case "repeat":
+      return convertRepeat(node);
+    case "foreach":
+      return convertForEach(node);
+    case "while":
+      return convertWhile(node);
+    // Expression nodes — wrap as `get` command with patient role
+    default:
+      return createCommandNode("get", { patient: convertValue(node) });
+  }
+}
+function convertEvent(node) {
+  const event = String(node.event ?? "click");
+  const bodyNodes = Array.isArray(node.body) ? node.body : [];
+  const body = bodyNodes.map(fromInterchangeNode);
+  const roles = {
+    event: createLiteral(event)
+  };
+  if (node.target && typeof node.target === "object") {
+    roles.source = convertValue(node.target);
+  }
+  const modifiers = node.modifiers;
+  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);
+  }
+  return createEventHandlerNode("on", roles, body, void 0, eventModifiers);
+}
+function convertCommand(node) {
+  const name = String(node.name ?? "unknown");
+  const args = Array.isArray(node.args) ? node.args : [];
+  const target = node.target && typeof node.target === "object" ? node.target : void 0;
+  const existingRoles = node.roles;
+  const modifiers = node.modifiers;
+  let roles;
+  if (existingRoles && typeof existingRoles === "object" && Object.keys(existingRoles).length > 0) {
+    roles = {};
+    for (const [role, value] of Object.entries(existingRoles)) {
+      if (value && typeof value === "object" && "type" in value) {
+        roles[role] = convertValue(value);
+      }
+    }
+  } else {
+    roles = inferRoles(name, args, modifiers, target);
+  }
+  return createCommandNode(name, roles);
+}
+function convertIf(node) {
+  const condition = node.condition && typeof node.condition === "object" ? convertValue(node.condition) : createExpression("true");
+  const thenBody = Array.isArray(node.thenBranch) ? node.thenBranch : [];
+  const thenBranch = thenBody.map(fromInterchangeNode);
+  let elseBranch;
+  const elseIfBranches = node.elseIfBranches;
+  if (elseIfBranches && elseIfBranches.length > 0) {
+    elseBranch = [chainElseIfs(elseIfBranches, node.elseBranch)];
+  } else if (Array.isArray(node.elseBranch) && node.elseBranch.length > 0) {
+    elseBranch = node.elseBranch.map(fromInterchangeNode);
+  }
+  const roles = { condition };
+  return createConditionalNode("if", roles, thenBranch, elseBranch);
+}
+function chainElseIfs(branches, finalElse) {
+  const [first, ...rest] = branches;
+  const condition = convertValue(first.condition);
+  const thenBranch = first.body.map(fromInterchangeNode);
+  let elseBranch;
+  if (rest.length > 0) {
+    elseBranch = [chainElseIfs(rest, finalElse)];
+  } else if (finalElse && finalElse.length > 0) {
+    elseBranch = finalElse.map(fromInterchangeNode);
+  }
+  return createConditionalNode("if", { condition }, thenBranch, elseBranch);
+}
+function convertRepeat(node) {
+  const bodyNodes = Array.isArray(node.body) ? node.body : [];
+  const body = bodyNodes.map(fromInterchangeNode);
+  const roles = {};
+  let variant;
+  if (node.count !== void 0 && node.count !== null) {
+    variant = "times";
+    if (typeof node.count === "number") {
+      roles.quantity = createLiteral(node.count, "number");
+    } else if (typeof node.count === "object") {
+      roles.quantity = convertValue(node.count);
+    }
+  } else if (node.whileCondition && typeof node.whileCondition === "object") {
+    variant = "while";
+    roles.condition = convertValue(node.whileCondition);
+  } else if (typeof node.untilEvent === "string") {
+    variant = "until";
+    roles.condition = createLiteral(node.untilEvent);
+  } else {
+    variant = "forever";
+  }
+  return createLoopNode("repeat", roles, variant, body);
+}
+function convertForEach(node) {
+  const bodyNodes = Array.isArray(node.body) ? node.body : [];
+  const body = bodyNodes.map(fromInterchangeNode);
+  const roles = {};
+  if (node.collection && typeof node.collection === "object") {
+    roles.source = convertValue(node.collection);
+  }
+  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);
+}
+function convertWhile(node) {
+  const bodyNodes = Array.isArray(node.body) ? node.body : [];
+  const body = bodyNodes.map(fromInterchangeNode);
+  const roles = {};
+  if (node.condition && typeof node.condition === "object") {
+    roles.condition = convertValue(node.condition);
+  }
+  return 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 ?? "")));
+    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"),
+        String(node.property ?? "")
+      );
+    // Complex expressions → collapse to raw string
+    case "binary":
+    case "unary":
+    case "member":
+    case "call":
+    case "positional":
+      return createExpression(renderExpr(node));
+    default:
+      if ("value" in node) return createLiteral(String(node.value ?? ""));
+      return createExpression(renderExpr(node));
+  }
+}
+function convertLiteral(node) {
+  const value = node.value;
+  if (value === null || value === void 0) return createLiteral("null");
+  const dataType = typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : void 0;
+  return createLiteral(value, dataType);
+}
+function convertIdentifier(node) {
+  const value = String(node.value ?? "");
+  if (DEFAULT_REFERENCES.has(value)) {
+    return createReference(value);
+  }
+  return createLiteral(value);
+}
+function convertVariable(node) {
+  const name = String(node.name ?? "");
+  const scope = String(node.scope ?? "local");
+  switch (scope) {
+    case "element":
+      return createExpression(`:${name}`);
+    case "global":
+      return createExpression(`$${name}`);
+    default:
+      return createExpression(name);
+  }
+}
+function renderExpr(node) {
+  if (!node || typeof node !== "object") return "";
+  switch (node.type) {
+    case "literal": {
+      const v = node.value;
+      if (v === null || v === void 0) return "null";
+      if (typeof v === "string") return /\s/.test(v) ? `"${v}"` : v;
+      return String(v);
+    }
+    case "identifier":
+      return String(node.value ?? "");
+    case "selector":
+      return String(node.value ?? "");
+    case "variable": {
+      const name = String(node.name ?? "");
+      const scope = String(node.scope ?? "local");
+      if (scope === "element") return `:${name}`;
+      if (scope === "global") return `$${name}`;
+      return name;
+    }
+    case "binary": {
+      const left = node.left && typeof node.left === "object" ? renderExpr(node.left) : "";
+      const right = node.right && typeof node.right === "object" ? renderExpr(node.right) : "";
+      return `${left} ${node.operator ?? ""} ${right}`;
+    }
+    case "unary": {
+      const operand = node.operand && typeof node.operand === "object" ? renderExpr(node.operand) : "";
+      return `${node.operator ?? ""} ${operand}`;
+    }
+    case "member": {
+      const obj = node.object && typeof node.object === "object" ? renderExpr(node.object) : "";
+      if (node.computed && node.property && typeof node.property === "object") {
+        return `${obj}[${renderExpr(node.property)}]`;
+      }
+      const prop = typeof node.property === "string" ? node.property : node.property && typeof node.property === "object" ? renderExpr(node.property) : "";
+      return `${obj}.${prop}`;
+    }
+    case "possessive": {
+      const obj = node.object && typeof node.object === "object" ? renderExpr(node.object) : "";
+      return `${obj}'s ${node.property ?? ""}`;
+    }
+    case "call": {
+      const callee = node.callee && typeof node.callee === "object" ? renderExpr(node.callee) : "";
+      const args = Array.isArray(node.args) ? node.args.map((a) => renderExpr(a)).join(", ") : "";
+      return `${callee}(${args})`;
+    }
+    case "positional": {
+      const target = node.target && typeof node.target === "object" ? renderExpr(node.target) : "";
+      return target ? `${node.position ?? ""} ${target}` : String(node.position ?? "");
+    }
+    default:
+      if ("value" in node) return String(node.value ?? "");
+      return "";
+  }
+}
+function inferRoles(name, args, modifiers, target) {
+  const roles = {};
+  switch (name) {
+    case "set": {
+      if (args[0]) roles.destination = convertValue(args[0]);
+      const toVal = modifiers?.to;
+      if (toVal && typeof toVal === "object" && "type" in toVal) {
+        roles.patient = convertValue(toVal);
+      } else if (args[1]) {
+        roles.patient = convertValue(args[1]);
+      }
+      break;
+    }
+    case "put": {
+      if (args[0]) roles.patient = convertValue(args[0]);
+      if (modifiers) {
+        for (const key of ["into", "before", "after"]) {
+          const val = modifiers[key];
+          if (val && typeof val === "object" && "type" in val) {
+            roles.destination = convertValue(val);
+            roles.method = createLiteral(key);
+            break;
+          }
+        }
+      }
+      if (!roles.destination && target) {
+        roles.destination = convertValue(target);
+      }
+      break;
+    }
+    case "increment":
+    case "decrement": {
+      if (args[0]) roles.destination = convertValue(args[0]);
+      const byVal = modifiers?.by;
+      if (byVal && typeof byVal === "object" && "type" in byVal) {
+        roles.quantity = convertValue(byVal);
+      } else if (args[1]) {
+        roles.quantity = convertValue(args[1]);
+      }
+      break;
+    }
+    case "fetch": {
+      if (args[0]) roles.source = convertValue(args[0]);
+      const asVal = modifiers?.as;
+      if (asVal && typeof asVal === "object" && "type" in asVal) {
+        roles.responseType = convertValue(asVal);
+      } else if (typeof asVal === "string") {
+        roles.responseType = createLiteral(asVal);
+      }
+      break;
+    }
+    case "wait":
+    case "settle": {
+      if (args[0]) roles.duration = convertValue(args[0]);
+      break;
+    }
+    case "toggle":
+    case "add":
+    case "show":
+    case "hide": {
+      if (args[0]) roles.patient = convertValue(args[0]);
+      if (target) roles.destination = convertValue(target);
+      break;
+    }
+    case "remove": {
+      if (args[0]) roles.patient = convertValue(args[0]);
+      if (target) roles.source = convertValue(target);
+      break;
+    }
+    case "send":
+    case "trigger": {
+      if (args[0]) roles.patient = convertValue(args[0]);
+      if (target) roles.destination = convertValue(target);
+      break;
+    }
+    case "log": {
+      if (args[0]) roles.patient = convertValue(args[0]);
+      break;
+    }
+    default: {
+      if (args[0]) roles.patient = convertValue(args[0]);
+      if (target) roles.destination = convertValue(target);
+      break;
+    }
+  }
+  return roles;
+}
+function inferSelectorKind2(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 inferValueFromString(value) {
+  if (DEFAULT_REFERENCES.has(value)) return createReference(value);
+  const kind = inferSelectorKind2(value);
+  if (kind) return createSelector(value, kind);
+  return createLiteral(value);
+}
+function bridgeEventModifiers(mods) {
+  const once = mods.once === true ? true : void 0;
+  const debounce = typeof mods.debounce === "number" ? mods.debounce : void 0;
+  const throttle = typeof mods.throttle === "number" ? mods.throttle : void 0;
+  const from = typeof mods.from === "string" ? inferValueFromString(mods.from) : void 0;
+  if (once === void 0 && debounce === void 0 && throttle === void 0 && from === void 0) {
+    return void 0;
+  }
+  return {
+    ...once !== void 0 ? { once } : {},
+    ...debounce !== void 0 ? { debounce } : {},
+    ...throttle !== void 0 ? { throttle } : {},
+    ...from !== void 0 ? { from } : {}
+  };
+}
+
+// src/ir/to-runtime-ast.ts
+function semanticNodeToRuntimeAST(node) {
+  switch (node.kind) {
+    case "event-handler":
+      return convertEventHandler(node);
+    case "conditional":
+      return convertConditional(node);
+    case "loop":
+      return convertLoop(node);
+    case "compound": {
+      const compound = node;
+      const commands = (compound.statements ?? []).map(semanticNodeToRuntimeAST);
+      return {
+        type: "CommandSequence",
+        commands
+      };
+    }
+    case "command":
+    default:
+      return convertCommand2(node);
+  }
+}
+function convertEventHandler(eh) {
+  const eventValue = eh.roles.get("event");
+  const eventName = eventValue && "value" in eventValue ? String(eventValue.value) : "click";
+  const modifiers = {};
+  if (eh.eventModifiers) {
+    if (eh.eventModifiers.once) modifiers.once = true;
+    if (eh.eventModifiers.debounce) modifiers.debounce = eh.eventModifiers.debounce;
+    if (eh.eventModifiers.throttle) modifiers.throttle = eh.eventModifiers.throttle;
+    if (eh.eventModifiers.queue) modifiers.queue = eh.eventModifiers.queue;
+  }
+  return {
+    type: "event",
+    event: eventName,
+    modifiers,
+    body: (eh.body ?? []).map(semanticNodeToRuntimeAST)
+  };
+}
+function convertCommand2(node) {
+  const roles = {};
+  const args = [];
+  for (const [roleName, value] of node.roles) {
+    const astValue = semanticValueToAST(value);
+    roles[roleName] = astValue;
+    args.push(astValue);
+  }
+  return {
+    type: "command",
+    name: node.action,
+    args,
+    roles
+  };
+}
+function convertConditional(node) {
+  const conditionValue = node.roles.get("condition");
+  return {
+    type: "command",
+    name: "if",
+    args: conditionValue ? [semanticValueToAST(conditionValue)] : [],
+    condition: conditionValue ? semanticValueToAST(conditionValue) : void 0,
+    thenBranch: (node.thenBranch ?? []).map(semanticNodeToRuntimeAST),
+    elseBranch: (node.elseBranch ?? []).map(semanticNodeToRuntimeAST)
+  };
+}
+function convertLoop(node) {
+  const countValue = node.roles.get("patient") || node.roles.get("count");
+  return {
+    type: "command",
+    name: "repeat",
+    args: countValue ? [semanticValueToAST(countValue)] : [],
+    loopVariant: node.loopVariant ?? "forever",
+    body: (node.body ?? []).map(semanticNodeToRuntimeAST),
+    loopVariable: node.loopVariable,
+    indexVariable: node.indexVariable
+  };
+}
+function semanticValueToAST(value) {
+  switch (value.type) {
+    case "selector":
+      return { type: "selector", value: value.value };
+    case "reference":
+      return { type: "identifier", value: value.value };
+    case "literal": {
+      const lit = value;
+      if (lit.dataType === "duration") {
+        const str = String(lit.value);
+        const match = /^(\d+(?:\.\d+)?)(ms|s)$/.exec(str);
+        if (match) {
+          const ms = match[2] === "s" ? parseFloat(match[1]) * 1e3 : parseFloat(match[1]);
+          return { type: "literal", value: ms };
+        }
+      }
+      return { type: "literal", value: lit.value };
+    }
+    case "property-path": {
+      const pp = value;
+      const objectAST = semanticValueToAST(pp.object);
+      return {
+        type: "member",
+        object: objectAST,
+        property: pp.property
+      };
+    }
+    case "expression": {
+      const expr = value;
+      return { type: "expression", value: expr.raw };
+    }
+    case "flag": {
+      const flag = value;
+      return { type: "literal", value: flag.enabled };
+    }
+    default:
+      return { type: "literal", value: String(value.value ?? "") };
+  }
+}
+export {
+  DEFAULT_REFERENCES,
+  convertValue,
+  fromEnvelopeJSON,
+  fromInterchangeNode,
+  fromProtocolJSON,
+  isCompoundSyntax,
+  isDocumentSyntax,
+  isEnvelope,
+  isExplicitSyntax,
+  isValidReference,
+  jsonToSemanticNode,
+  parseCompound,
+  parseDocument,
+  parseExplicit,
+  renderDocument,
+  renderExplicit,
+  renderExpr,
+  semanticNodeToJSON,
+  semanticNodeToRuntimeAST,
+  semanticValueToAST,
+  toEnvelopeJSON,
+  toProtocolJSON,
+  validateProtocolJSON,
+  validateSemanticJSON
+};
+//# sourceMappingURL=index.js.map