@lokascript/compilation-service 2.0.0 → 2.1.0

package/dist/index.cjs

@@ -41,6 +41,7 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 // ../core/dist/index.mjs
 var dist_exports = {};
 __export(dist_exports, {
+  DebugController: () => DebugController,
   Lexer: () => Lexer,
   Runtime: () => Runtime,
   RuntimeBase: () => RuntimeBase,
@@ -56,6 +57,7 @@ __export(dist_exports, {
   createBehaviorsFeature: () => createBehaviorsFeature,
   createChildContext: () => createChildContext,
   createContext: () => createContext,
+  createDebugController: () => createDebugController,
   createDef: () => createDef,
   createDefFeature: () => createDefFeature,
   createEventSource: () => createEventSource,
@@ -6843,6 +6845,65 @@ function createReference$1(value) {
 function createPropertyPath$1(object, property) {
   return { type: "property-path", object, property };
 }
+function createFlag(name, enabled = true) {
+  return { type: "flag", name, enabled };
+}
+function createCommandNode$1(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,
+    ...metadata && { metadata }
+  };
+}
+function createConditionalNode$1(action, roles, thenBranch, elseBranch, metadata) {
+  const rolesMap = roles instanceof Map ? roles : new Map(Object.entries(roles));
+  const base = {
+    kind: "conditional",
+    action,
+    roles: rolesMap,
+    thenBranch
+  };
+  return {
+    ...base,
+    ...elseBranch && { elseBranch },
+    ...metadata && { metadata }
+  };
+}
+function createLoopNode$1(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 createLogger(namespace) {
   return new DebugLogger(namespace);
 }
@@ -6880,6 +6941,341 @@ function createTokenizerContext(tokenizer) {
   }
   return ctx;
 }
+function isValidReference2(value, referenceSet = DEFAULT_REFERENCES) {
+  return referenceSet.has(value);
+}
+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$1(input, options = {}) {
+  const trimmed = input.trim();
+  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 command2 = tokens[0].toLowerCase();
+  const roles = /* @__PURE__ */ new Map();
+  const refSet = options.referenceSet ?? DEFAULT_REFERENCES;
+  const schema = options.schemaLookup?.getSchema(command2);
+  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) {
+        throw new Error(`Empty flag name: "${token}"`);
+      }
+      if (validRoleNames && !validRoleNames.has(flagName)) {
+        const roleList = [...validRoleNames].join(", ");
+        throw new Error(
+          `Unknown flag "${flagName}" for command "${command2}". Valid roles: ${roleList}`
+        );
+      }
+      roles.set(flagName, createFlag(flagName, enabled));
+      continue;
+    }
+    const colonIndex = token.indexOf(":");
+    if (colonIndex === -1) {
+      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(", ");
+      throw new Error(
+        `Unknown role "${roleName}" for command "${command2}". 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 && command2 !== "on") {
+    for (const roleSpec of schema.roles) {
+      if (roleSpec.required && !roles.has(roleSpec.role) && !roleSpec.default) {
+        throw new Error(
+          `Missing required role "${roleSpec.role}" for command "${command2}": ${roleSpec.description}`
+        );
+      }
+    }
+  }
+  switch (command2) {
+    case "on": {
+      const eventValue = roles.get("event");
+      if (!eventValue) {
+        throw new Error("Event handler requires event role: [on event:click ...]");
+      }
+      const body = extractStructuralBody(roles, "body", options);
+      roles.delete("body");
+      return 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 createConditionalNode$1(
+        command2,
+        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 createLoopNode$1(command2, roles, variant, loopBody, loopVariable, indexVariable, {
+        sourceLanguage: "explicit"
+      });
+    }
+    default:
+      return createCommandNode$1(command2, roles, {
+        sourceLanguage: "explicit"
+      });
+  }
+}
+function isExplicitSyntax(input) {
+  const trimmed = input.trim();
+  return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+function extractStructuralBody(roles, roleName, options) {
+  const value = roles.get(roleName);
+  if (!value) return [];
+  if (value.type === "expression") {
+    return [parseExplicit$1(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$1(valueStr, inferSelectorKind(valueStr));
+  }
+  if (valueStr.startsWith('"') || valueStr.startsWith("'")) {
+    const inner = valueStr.slice(1, -1);
+    return createLiteral$1(inner, "string");
+  }
+  if (valueStr === "true") return createLiteral$1(true, "boolean");
+  if (valueStr === "false") return createLiteral$1(false, "boolean");
+  const lowerRef = valueStr.toLowerCase();
+  if (isValidReference2(lowerRef, referenceSet)) {
+    return createReference$1(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$1(valueStr, "duration");
+    }
+    return createLiteral$1(num, "number");
+  }
+  return createLiteral$1(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;
+}
+function renderExplicit$1(node) {
+  if (node.kind === "compound") {
+    const compoundNode = node;
+    const renderedStatements = compoundNode.statements.map((stmt) => renderExplicit$1(stmt));
+    return renderedStatements.join(` ${compoundNode.chainType} `);
+  }
+  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$1(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$1(n));
+      parts.push(`then:${thenParts.join(" ")}`);
+    }
+    if (condNode.elseBranch && condNode.elseBranch.length > 0) {
+      const elseParts = condNode.elseBranch.map((n) => renderExplicit$1(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$1(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$1(n));
+      parts.push(`body:${bodyParts.join(" ")}`);
+    }
+    if (cmd.catchBranch && cmd.catchBranch.length > 0) {
+      const catchParts = cmd.catchBranch.map((n) => renderExplicit$1(n));
+      parts.push(`catch:${catchParts.join(" ")}`);
+    }
+    if (cmd.finallyBranch && cmd.finallyBranch.length > 0) {
+      const finallyParts = cmd.finallyBranch.map((n) => renderExplicit$1(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$1(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;
+  }
+}
 function createPosition(start, end) {
   return { start, end };
 }
@@ -7702,6 +8098,20 @@ function validateCommandSchema(schema) {
       );
     }
   }
+  for (const role of schema.roles) {
+    if (role.selectorKinds && role.selectorKinds.length > 0) {
+      if (!role.expectedTypes.includes("selector")) {
+        items.push(
+          createSchemaValidationItem(
+            SchemaErrorCodes.SELECTOR_KINDS_WITHOUT_SELECTOR_TYPE,
+            "warning",
+            { role: role.role },
+            role.role
+          )
+        );
+      }
+    }
+  }
   switch (schema.action) {
     case "transition":
       validateTransitionSchema(schema, items);
@@ -7866,6 +8276,34 @@ function getValidationStats(validations) {
     byCode
   };
 }
+function validateRoleValues(schema, values) {
+  const diagnostics = [];
+  for (const value of values) {
+    const roleSpec = schema.roles.find((r) => r.role === value.role);
+    if (!roleSpec) continue;
+    if (roleSpec.expectedTypes.length > 0 && !roleSpec.expectedTypes.includes(value.type)) {
+      if (!roleSpec.expectedTypes.includes("expression")) {
+        diagnostics.push({
+          level: "error",
+          role: value.role,
+          message: `${schema.action}.${value.role} expects type [${roleSpec.expectedTypes.join(", ")}], got '${value.type}'`,
+          code: SchemaErrorCodes.VALUE_TYPE_MISMATCH
+        });
+      }
+    }
+    if (value.type === "selector" && value.selectorKind && roleSpec.selectorKinds && roleSpec.selectorKinds.length > 0) {
+      if (!roleSpec.selectorKinds.includes(value.selectorKind)) {
+        diagnostics.push({
+          level: "error",
+          role: value.role,
+          message: `${schema.action}.${value.role} expects selector kind [${roleSpec.selectorKinds.join(", ")}], got '${value.selectorKind}'`,
+          code: SchemaErrorCodes.SELECTOR_KIND_MISMATCH
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
 function validateKeywordCollisions(profile) {
   const collisions = [];
   if (!profile.keywords) {
@@ -9534,7 +9972,7 @@ function createLiteral(value, dataType) {
   return result;
 }
 function isValidReference(value) {
-  return VALID_REFERENCES.has(value);
+  return isValidReference2(value);
 }
 function createReference(value) {
   return { type: "reference", value };
@@ -9679,163 +10117,10 @@ function renderExplicit(node) {
   return semanticRenderer.renderExplicit(node);
 }
 function parseExplicit(input) {
-  const trimmed = input.trim();
-  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 command2 = tokens[0].toLowerCase();
-  const roles = /* @__PURE__ */ new Map();
-  const schema = getSchema(command2);
-  const validRoleNames = schema ? new Set(schema.roles.map((r) => r.role)) : null;
-  for (let i = 1; i < tokens.length; i++) {
-    const token = tokens[i];
-    const colonIndex = token.indexOf(":");
-    if (colonIndex === -1) {
-      throw new Error(`Invalid role format: "${token}". Expected role:value`);
-    }
-    const roleName = token.slice(0, colonIndex);
-    if (validRoleNames && roleName !== "body" && !validRoleNames.has(roleName)) {
-      const roleList = [...validRoleNames].join(", ");
-      throw new Error(
-        `Unknown role "${roleName}" for command "${command2}". Valid roles: ${roleList}`
-      );
-    }
-    const role = roleName;
-    const valueStr = token.slice(colonIndex + 1);
-    if (role === "body" && valueStr.startsWith("[")) {
-      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);
-    roles.set(role, value);
-  }
-  if (schema && command2 !== "on") {
-    for (const roleSpec of schema.roles) {
-      if (roleSpec.required && !roles.has(roleSpec.role) && !roleSpec.default) {
-        throw new Error(
-          `Missing required role "${roleSpec.role}" for command "${command2}": ${roleSpec.description}`
-        );
-      }
-    }
-  }
-  if (command2 === "on") {
-    const eventValue = roles.get("event");
-    if (!eventValue) {
-      throw new Error("Event handler requires event role: [on event:click ...]");
-    }
-    const bodyValue = roles.get("body");
-    const body = [];
-    if (bodyValue && bodyValue.type === "expression") {
-      body.push(parseExplicit(bodyValue.raw));
-    }
-    roles.delete("body");
-    return createEventHandler(eventValue, body, void 0, {
-      sourceLanguage: "explicit"
-    });
-  }
-  const rolesObj = {};
-  for (const [role, value] of roles) {
-    rolesObj[role] = value;
-  }
-  return createCommandNode(command2, rolesObj, {
-    sourceLanguage: "explicit"
+  return parseExplicit$1(input, {
+    schemaLookup: hyperscriptSchemaLookup
   });
 }
-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) {
-  if (valueStr.startsWith("#") || valueStr.startsWith(".") || valueStr.startsWith("[") || valueStr.startsWith("@") || valueStr.startsWith("*")) {
-    return createSelector(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)) {
-    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, "string");
-}
-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;
-}
-function isExplicitSyntax(input) {
-  const trimmed = input.trim();
-  return trimmed.startsWith("[") && trimmed.endsWith("]");
-}
 function parse(input, language) {
   return semanticParser.parse(input, language);
 }
@@ -17417,6 +17702,8 @@ function semanticValuesEqual(a, b) {
       return semanticValuesEqual(a.object, b.object) && a.property === b.property;
     case "expression":
       return a.raw === b.raw;
+    case "flag":
+      return a.name === b.name && a.enabled === b.enabled;
     default:
       return false;
   }
@@ -18195,6 +18482,8 @@ function convertValue(value, warnings) {
       return convertPropertyPath(value, warnings);
     case "expression":
       return convertExpression(value);
+    case "flag":
+      return { type: "literal", value: value.enabled };
     default:
       const _exhaustive = value;
       throw new Error(`Unknown semantic value type: ${_exhaustive.type}`);
@@ -18748,7 +19037,7 @@ function parseSemantic(code, language) {
 }
 function createHistorySwap(config2) {
   const { target, strategy = "morph", useViewTransition = false, fetchOptions = {}, transformUrl, onBeforeFetch, onAfterSwap, onError } = config2;
-  const resolveTarget2 = () => {
+  const resolveTarget3 = () => {
     if (typeof target === "string") {
       const element = document.querySelector(target);
       return isHTMLElement(element) ? element : null;
@@ -18756,7 +19045,7 @@ function createHistorySwap(config2) {
     return isHTMLElement(target) ? target : null;
   };
   const handlePopstate = async (_event) => {
-    const targetElement = resolveTarget2();
+    const targetElement = resolveTarget3();
     if (!targetElement) {
       console.warn(`HistorySwap: target "${target}" not found`);
       return;
@@ -18851,7 +19140,7 @@ function shouldHandleClick(event) {
 }
 function createBoosted(config2) {
   const { container, target, linkSelector = "a[href]", formSelector = "form", boostForms = false, strategy = "morph", pushUrl = true, useViewTransition = false, fetchOptions = {}, onBeforeFetch, onAfterSwap, onError } = config2;
-  const resolveTarget2 = () => {
+  const resolveTarget3 = () => {
     if (!target) {
       return document.body;
     }
@@ -18862,7 +19151,7 @@ function createBoosted(config2) {
     return isHTMLElement(target) ? target : null;
   };
   const boost = async (url, method = "GET", body = null) => {
-    const targetElement = resolveTarget2();
+    const targetElement = resolveTarget3();
     if (!targetElement) {
       console.warn(`Boosted: target "${target}" not found`);
       return;
@@ -19198,6 +19487,46 @@ function process$1(element) {
     console.error("Error processing hyperscript node:", error);
   }
 }
+function serializeValue(value) {
+  if (value === null || value === void 0)
+    return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Element) {
+    return describeElement(value);
+  }
+  if (Array.isArray(value)) {
+    return `Array(${value.length})`;
+  }
+  if (value instanceof Map) {
+    return `Map(${value.size})`;
+  }
+  if (value instanceof Set) {
+    return `Set(${value.size})`;
+  }
+  if (typeof value === "function") {
+    return `\u0192 ${value.name || "anonymous"}()`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length <= 3) {
+      return `{${keys.join(", ")}}`;
+    }
+    return `{${keys.slice(0, 3).join(", ")}, ...${keys.length - 3} more}`;
+  }
+  return String(value);
+}
+function describeElement(el) {
+  let desc = `<${el.tagName.toLowerCase()}`;
+  if (el.id)
+    desc += `#${el.id}`;
+  if (el.classList.length > 0) {
+    desc += `.${Array.from(el.classList).join(".")}`;
+  }
+  desc += ">";
+  return desc;
+}
 async function getOrCreateBridge() {
   if (!bridgeInstance) {
     const { SemanticGrammarBridge: SemanticGrammarBridge2 } = await Promise.resolve().then(function() {
@@ -19224,6 +19553,13 @@ function getDefaultParserOptions() {
     semanticConfidenceThreshold: config.confidenceThreshold
   };
 }
+function getDebugController() {
+  if (!_debugController) {
+    _debugController = new DebugController();
+    getDefaultRuntime().registerHooks("__debugger", _debugController.hooks);
+  }
+  return _debugController;
+}
 function getDefaultRuntime() {
   if (!_defaultRuntime) {
     _defaultRuntime = new Runtime({
@@ -20278,6 +20614,9 @@ function flattenEventModifiers(modifiers) {
     flat.from = modifiers.from;
   return flat;
 }
+function createDebugController() {
+  return new DebugController();
+}
 async function getSemanticModule() {
   if (!_semanticModule) {
     _semanticModule = await Promise.resolve().then(function() {
@@ -20286,7 +20625,7 @@ async function getSemanticModule() {
   }
   return _semanticModule;
 }
-var KEYWORDS$2, COMMAND_TERMINATORS, COMMANDS, COMPOUND_COMMANDS, CONTROL_FLOW_COMMANDS, PUT_OPERATIONS, PUT_OPERATION_KEYWORDS, HYPERSCRIPT_KEYWORDS, CommandClassification, CSS_FUNCTIONS, CONTEXT_VARS$1, LOGICAL_OPERATORS$1, COMPARISON_OPERATORS, DOM_EVENTS, TOKENIZER_KEYWORDS, TokenKind, TokenType, KEYWORDS$1, MATHEMATICAL_OPERATORS, TIME_UNITS$1, isDebugEnabled$1, DEBUG, debug, debugEnabled, debugEventTarget, stats, DEFAULT_CONFIDENCE_THRESHOLD$1, SemanticIntegrationAdapter, MULTI_WORD_PATTERNS, DEFAULT_BOUNDARY_KEYWORDS, CommandNodeBuilder, SWAP_STRATEGY_KEYWORDS, Parser, HookRegistry, CleanupRegistry, sharedGlobals, EventSourceRegistry, ContextProviderRegistry, ExpressionTypeRegistry, expressionTypeRegistry, BOOLEAN_ATTRIBUTES, SPECIAL_DOM_PROPERTIES, BaseExpressionEvaluator, NUMBER_WORDS, isProduction, skipValidation, addDescribeToValidator, v, z, BaseExpressionImpl, MeExpression, YouExpression, ItExpression, CSSelectorInputSchema, CSSSelectorExpression, meExpression, youExpression, itExpression, itsExpression$1, resultExpression, querySelectorExpression, querySelectorAllExpression, idExpression, classExpression, closestExpression, parentExpression, windowExpression, documentExpression, elementWithSelectorExpression, styleRefExpression, possessiveStyleRefExpression, ofStyleRefExpression, referencesExpressions, LRUCache, HyperscriptCache, globalCache, PerformanceTracker, performanceTracker, cleanupInterval, BinaryLogicalInputSchema, UnaryLogicalInputSchema, AndExpression, OrExpression, NotExpression, ComparisonInputSchema, PatternMatchingInputSchema, equalsExpression, strictEqualsExpression, notEqualsExpression, strictNotEqualsExpression, lessThanExpression, lessThanOrEqualExpression, greaterThanExpression, greaterThanOrEqualExpression, andExpression, orExpression, notExpression, isEmptyExpression, noExpression, isNotEmptyExpression, existsExpression, doesNotExistExpression, containsExpression, doesNotContainExpression, startsWithExpression, endsWithExpression, matchesExpression, hasExpression, doesNotHaveExpression, logicalExpressions, enhancedConverters, AsExpressionInputSchema, AsExpression, IsExpressionInputSchema, IsExpression, defaultConversions, asExpression, isExpression, asyncExpression, conversionExpressions, evaluationToHyperScriptType, CollectionInputSchema, IndexInputSchema, RandomInputSchema, FirstExpression, LastExpression, AtExpression, RandomExpression, firstExpression, lastExpression, atExpression, nextExpression, previousExpression, nextWithinExpression, previousWithinExpression, positionalExpressions, UNSAFE_PROPS, possessiveExpression, myExpression, itsExpression, yourExpression, ofExpression, attributeExpression, attributeWithValueExpression, classReferenceExpression, idReferenceExpression, propertiesExpressions, StringLiteralInputSchema, NumberLiteralInputSchema, BooleanLiteralInputSchema, BinaryOperationInputSchema, StringLiteralExpression, NumberLiteralExpression, BooleanLiteralExpression, AdditionExpression, StringConcatenationExpression, MultiplicationExpression, specialExpressions, ExpressionEvaluator, ContextBridge, CommandAdapterV2, CommandRegistryV2, defaultRegistry, RegistryIntegration, eventRecursionDepth, RuntimeBase, COMMAND_NAME, COMMAND_CATEGORY, COMMAND_METADATA, KEYWORD_PREPOSITIONS, VisibilityCommandBase, HideCommand, createHideCommand, ShowCommand, createShowCommand, SMART_ELEMENT_TAGS, DOMModificationBase, AddCommand, createAddCommand, RemoveCommand, createRemoveCommand, PATTERN, BOOL_PROPS, ToggleCommand, createToggleCommand, PutCommand, createPutCommand, MakeCommand, createMakeCommand, SUPPORTS_MOVE_BEFORE, ELEMENT_NODE_TYPE, TEXT_NODE_TYPE, IS_PARENT_NODE_TYPE, Operation, candidateNodes, candidateElements, unmatchedNodes, unmatchedElements, whitespaceNodes, _idArrayMap, _idSetMap, _options, _Morph_instances, morphOneToMany_fn, morphOneToOne_fn, morphMatchingElements_fn, morphNonMatchingElements_fn, morphOtherNode_fn, visitAttributes_fn, visitTextArea_fn, replaceNode_fn, removeNode_fn, mapIdArraysForEach_fn, mapIdArrays_fn, mapIdSets_fn, Morph, morphlexMorph, morphlexMorphInner, morphlexEngine, currentEngine, morphAdapter, config$1, transitionQueue, isProcessingQueue, CRITICAL_LAYOUT_ELEMENTS, STRUCTURAL_SEMANTIC_ELEMENTS, WARNING_ELEMENTS, DEFAULT_VALIDATION_CONFIG, globalConfig, STYLES, SEVERITY_ICONS, SEVERITY_LABELS, STRATEGY_KEYWORDS, SwapCommand, MorphCommand, createSwapCommand, createMorphCommand, STRATEGY_MAP, ProcessPartialsCommand, createProcessPartialsCommand, WaitCommand, createWaitCommand, customResponseTypes, FetchCommand, createFetchCommand, SetCommand, createSetCommand, GetCommand, createGetCommand, NumericModifyCommand, createIncrementCommand, createDecrementCommand, LogCommand, createLogCommand, EventDispatchCommand, createTriggerCommand, createSendCommand, GoCommand, createGoCommand, KEYWORDS, HistoryCommand, createPushUrlCommand, createReplaceUrlCommand, ConditionalCommand, createConditionalCommand, createIfCommand, createUnlessCommand, RepeatCommand, createRepeatCommand, ControlFlowSignalBase, BreakCommand, createBreakCommand, ContinueCommand, createContinueCommand, HaltCommand, createHaltCommand, ReturnCommand, createReturnCommand, ExitCommand, createExitCommand, CallCommand, createCallCommand, AppendCommand, createAppendCommand, TransitionCommand, createTransitionCommand, MeasureCommand, createMeasureCommand, SettleCommand, createSettleCommand, JsCommand, createJsCommand, AsyncCommand, createAsyncCommand, DefaultCommand, createDefaultCommand, PseudoCommand, TellCommand, createTellCommand, CopyCommand, createCopyCommand, PickCommand, createPickCommand, ThrowCommand, createThrowCommand, BeepCommand, createBeepCommand, InstallCommand, TakeCommand, createTakeCommand, RenderCommand, Runtime, DebugLogger, _PatternMatcher$1, PatternMatcher$1, StringLiteralExtractor, NumberExtractor, IdentifierExtractor, TokenStreamImpl, DEFAULT_OPERATORS$1, _BaseTokenizer, BaseTokenizer, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __esm2, __export2, __copyProps2, __toCommonJS2, tokenizers, profiles, patternCache, patternGenerator, registeredPatterns, init_registry, init_token_utils, init_char_classifiers, init_base_tokenizer, init_base, init_types, COMBINED_PREFIXES, SINGLE_PREFIXES, VERB_PREFIXES, SUFFIXES, ArabicMorphologicalNormalizer, init_arabic_normalizer, arabic_exports, arabicProfile, init_arabic, DEFAULT_OPERATORS, OperatorExtractor, DEFAULT_PUNCTUATION, PunctuationExtractor, init_generic_extractors, CssSelectorExtractor, init_css_selector, EventModifierExtractor, init_event_modifier, UrlExtractor, init_url, VariableRefExtractor, init_variable_ref, JapaneseKeywordExtractor, init_japanese_keyword, SINGLE_CHAR_PARTICLES, MULTI_CHAR_PARTICLES, JapaneseParticleExtractor, init_japanese_particle, TEMPORAL_EVENT_SUFFIXES, KoreanKeywordExtractor, init_korean_keyword, SINGLE_CHAR_PARTICLES2, MULTI_CHAR_PARTICLES2, KoreanParticleExtractor, init_korean_particle, ChineseKeywordExtractor, init_chinese_keyword, SINGLE_CHAR_PARTICLES3, MULTI_CHAR_PARTICLES3, ChineseParticleExtractor, init_chinese_particle, isVietnameseLetter, isVietnameseIdentifierChar, PREPOSITIONS, VietnameseKeywordExtractor, init_vietnamese_keyword, isArabic2, PREPOSITIONS2, ArabicKeywordExtractor, init_arabic_keyword, isArabic3, PROCLITICS, ArabicProcliticExtractor, init_arabic_proclitic, isArabic4, TEMPORAL_MARKERS, ArabicTemporalExtractor, init_arabic_temporal, CyrillicKeywordExtractor, RUSSIAN_PREPOSITIONS, UKRAINIAN_PREPOSITIONS, init_cyrillic_keyword, HindiKeywordExtractor, init_hindi_keyword, SINGLE_POSTPOSITIONS, COMPOUND_POSTPOSITIONS, HindiParticleExtractor, init_hindi_particle, BengaliKeywordExtractor, init_bengali_keyword, SINGLE_POSTPOSITIONS2, BengaliParticleExtractor, init_bengali_particle, ThaiKeywordExtractor, init_thai_keyword, MalayKeywordExtractor, init_malay_keyword, PREPOSITIONS3, TagalogKeywordExtractor, init_tagalog_keyword, PREPOSITIONS4, isPolishLetter, isPolishIdentifierChar, PolishKeywordExtractor, init_polish_keyword, PREPOSITIONS5, isIndonesianLetter, isIndonesianIdentifierChar, IndonesianKeywordExtractor, init_indonesian_keyword, PREPOSITIONS6, isSwahiliLetter, isSwahiliIdentifierChar, SwahiliKeywordExtractor, init_swahili_keyword, POSTPOSITIONS, CASE_SUFFIXES, TurkishKeywordExtractor, init_turkish_keyword, SUFFIXES2, POSTPOSITIONS2, QuechuaKeywordExtractor, init_quechua_keyword, isHebrew, PREPOSITIONS7, CONJUNCTIONS, HebrewKeywordExtractor, init_hebrew_keyword, isHebrew2, PROCLITIC_PREFIXES, EVENT_MARKER_PREFIXES, EVENT_NAMES, HebrewProcliticExtractor, init_hebrew_proclitic, AsciiIdentifierExtractor, init_ascii_identifier, init_extractors, init_extractor_helpers, arabic_exports2, CONJUNCTIONS2, PREPOSITIONS8, ARABIC_EXTRAS, ArabicTokenizer, arabicTokenizer, init_arabic2, SUFFIX_RULES, BengaliMorphologicalNormalizer, bengaliMorphologicalNormalizer, init_bengali_normalizer, bengali_exports, bengaliProfile, init_bengali, bengali_exports2, SINGLE_POSTPOSITIONS3, BENGALI_EXTRAS, BengaliTokenizer, bengaliTokenizer, init_bengali2, german_exports, germanProfile, init_german, SEPARABLE_PREFIXES, VERB_ENDINGS, ELN_ERN_ENDINGS, ALL_ENDINGS, GermanMorphologicalNormalizer, init_german_normalizer, isGermanLetter, isGermanIdentifierChar, PREPOSITIONS9, GermanKeywordExtractor, init_german_keyword, german_exports2, GERMAN_EXTRAS, GermanTokenizer, germanTokenizer, init_german2, english_exports, englishProfile, init_english, EnglishKeywordExtractor, init_english_keyword, english_exports2, ENGLISH_EXTRAS, EnglishTokenizer, englishTokenizer, init_english2, SchemaErrorCodes, SchemaErrorMessages, SchemaErrorSuggestions, init_schema_error_codes, schema_validator_exports, MULTI_TYPE_PATIENT_COMMANDS, NO_REQUIRED_ROLES_COMMANDS, init_schema_validator, toggleSchema, addSchema, removeSchema, putSchema, setSchema, showSchema, hideSchema, onSchema, triggerSchema, waitSchema, fetchSchema, incrementSchema, decrementSchema, appendSchema, prependSchema, logSchema, getCommandSchema, takeSchema, makeSchema, haltSchema, settleSchema, throwSchema, sendSchema, ifSchema, unlessSchema, elseSchema, repeatSchema, forSchema, whileSchema, continueSchema, goSchema, transitionSchema, cloneSchema, focusSchema, blurSchema, callSchema, returnSchema, jsSchema, asyncSchema, tellSchema, defaultSchema, initSchema, behaviorSchema, installSchema, measureSchema, swapSchema, morphSchema, beepSchema, breakSchema, copySchema, exitSchema, pickSchema, renderSchema, commandSchemas, init_command_schemas, init_role_positioning, init_marker_resolution, init_event_handlers_sov, init_event_handlers_vso, defaultConfig, init_pattern_generator, init_en, init_en2, init_en3, en_exports, fetchWithResponseTypeEnglish, fetchSimpleEnglish, swapSimpleEnglish, repeatUntilEventFromEnglish, repeatUntilEventEnglish, setPossessiveEnglish, forEnglish, ifEnglish, unlessEnglish, temporalInEnglish, temporalAfterEnglish, init_en4, REFLEXIVE_SUFFIXES, AR_ENDINGS, ER_ENDINGS, IR_ENDINGS, ALL_ENDINGS2, SpanishMorphologicalNormalizer, init_spanish_normalizer, spanish_exports, spanishProfile, init_spanish, isSpanishLetter, isSpanishIdentifierChar, PREPOSITIONS10, SpanishKeywordExtractor, init_spanish_keyword, spanish_exports2, PREPOSITIONS11, SPANISH_EXTRAS, SpanishTokenizer, spanishTokenizer, init_spanish2, french_exports, frenchProfile, init_french, REFLEXIVE_SUFFIXES2, ER_ENDINGS2, IR_ENDINGS2, RE_ENDINGS, ALL_ENDINGS3, FrenchMorphologicalNormalizer, init_french_normalizer, isFrenchLetter, isFrenchIdentifierChar, PREPOSITIONS12, FrenchKeywordExtractor, init_french_keyword, french_exports2, FRENCH_EXTRAS, FrenchTokenizer, frenchTokenizer, init_french2, hebrewProfile, init_hebrew, PREPOSITIONS13, HEBREW_EXTRAS, HebrewTokenizer, hebrewTokenizer, init_he, SUFFIX_RULES2, HindiMorphologicalNormalizer, init_hindi_normalizer, hindi_exports, hindiProfile, init_hindi, hindi_exports2, SINGLE_POSTPOSITIONS4, HINDI_EXTRAS, HindiTokenizer, hindiTokenizer, init_hindi2, indonesian_exports, indonesianProfile, init_indonesian, indonesian_exports2, PREPOSITIONS14, INDONESIAN_EXTRAS, IndonesianTokenizer, indonesianTokenizer, init_indonesian2, REFLEXIVE_SUFFIXES3, ARE_ENDINGS, ERE_ENDINGS, IRE_ENDINGS, ALL_ENDINGS4, ItalianMorphologicalNormalizer, init_italian_normalizer, italian_exports, italianProfile, init_italian, RomanceKeywordExtractor, ITALIAN_PREPOSITIONS, init_romance_language_keyword, italian_exports2, PREPOSITIONS15, ITALIAN_EXTRAS, ItalianTokenizer, italianTokenizer, init_italian2, JAPANESE_SUFFIX_RULES, SURU_PATTERNS, JapaneseMorphologicalNormalizer, init_japanese_normalizer, japanese_exports, japaneseProfile, init_japanese, japanese_exports2, PARTICLES, JAPANESE_EXTRAS, JapaneseTokenizer, japaneseTokenizer, init_japanese2, KOREAN_SUFFIX_RULES, HADA_PATTERNS, KoreanMorphologicalNormalizer, init_korean_normalizer, korean_exports, koreanProfile, init_korean, korean_exports2, PARTICLES2, KOREAN_EXTRAS, KoreanTokenizer, koreanTokenizer, init_korean2, ms_exports, malayProfile, init_ms, ms_exports2, MALAY_EXTRAS, MalayTokenizer, malayTokenizer, init_ms2, polish_exports, polishProfile, init_polish, IMPERATIVE_TO_INFINITIVE, PolishMorphologicalNormalizer, init_polish_normalizer, polish_exports2, PREPOSITIONS16, POLISH_EXTRAS, PolishTokenizer, polishTokenizer, init_polish2, portuguese_exports, portugueseProfile, init_portuguese, REFLEXIVE_SUFFIXES4, AR_ENDINGS2, ER_ENDINGS3, IR_ENDINGS3, ALL_ENDINGS5, PortugueseMorphologicalNormalizer, init_portuguese_normalizer, isPortugueseLetter, isPortugueseIdentifierChar, PREPOSITIONS17, PortugueseKeywordExtractor, init_portuguese_keyword, portuguese_exports2, PREPOSITIONS18, PORTUGUESE_EXTRAS, PortugueseTokenizer, portugueseTokenizer, init_portuguese2, quechua_exports, quechuaProfile, init_quechua, QUECHUA_SUFFIX_RULES, QuechuaMorphologicalNormalizer, quechuaMorphologicalNormalizer, init_quechua_normalizer, quechua_exports2, QuechuaStringLiteralExtractor, SUFFIXES3, QUECHUA_EXTRAS, QuechuaTokenizer, quechuaTokenizer, init_quechua2, IMPERATIVE_TO_INFINITIVE2, RussianMorphologicalNormalizer, init_russian_normalizer, russian_exports, russianProfile, init_russian, russian_exports2, PREPOSITIONS19, RUSSIAN_EXTRAS, RussianTokenizer, russianTokenizer, init_russian2, swahili_exports, swahiliProfile, init_swahili, swahili_exports2, PREPOSITIONS20, SWAHILI_EXTRAS, SwahiliTokenizer, swahiliTokenizer, init_swahili2, thai_exports, thaiProfile, init_thai, thai_exports2, THAI_EXTRAS, ThaiTokenizer, thaiTokenizer, init_thai2, tl_exports, tagalogProfile, init_tl, COMBINED_PREFIXES2, SINGLE_PREFIXES2, INFIXES, SUFFIXES4, TagalogMorphologicalNormalizer, tagalogMorphologicalNormalizer, init_tagalog_normalizer, tl_exports2, TAGALOG_EXTRAS, TagalogTokenizer, tagalogTokenizer, init_tl2, TURKISH_SUFFIX_RULES, TurkishMorphologicalNormalizer, init_turkish_normalizer, turkish_exports, turkishProfile, init_turkish, turkish_exports2, POSTPOSITIONS3, CASE_SUFFIXES2, TURKISH_EXTRAS, TurkishTokenizer, turkishTokenizer, init_turkish2, IMPERATIVE_TO_INFINITIVE3, UkrainianMorphologicalNormalizer, init_ukrainian_normalizer, ukrainian_exports, ukrainianProfile, init_ukrainian, ukrainian_exports2, PREPOSITIONS21, UKRAINIAN_EXTRAS, UkrainianTokenizer, ukrainianTokenizer, init_ukrainian2, vietnamese_exports, vietnameseProfile, init_vietnamese, vietnamese_exports2, VIETNAMESE_EXTRAS, VietnameseTokenizer, vietnameseTokenizer, init_vietnamese2, chinese_exports, chineseProfile, init_chinese, chinese_exports2, PARTICLES3, CHINESE_EXTRAS, ChineseTokenizer, chineseTokenizer, init_chinese2, VALID_REFERENCES, init_types2, eventNameTranslations, init_shared, init_tokenizers, init_type_validation, init_possessive_keywords, _PatternMatcher2, PatternMatcher, patternMatcher, init_pattern_matcher, SemanticRendererImpl, semanticRenderer, init_renderer, init_parser, semantic_parser_exports, _SemanticParserImpl, SemanticParserImpl, semanticParser, init_semantic_parser, spanishMexicoProfile, fetchWithResponseTypeEnglish2, fetchSimpleEnglish2, fetchPatternsEn, swapSimpleEnglish2, swapPatternsEn, repeatUntilEventFromEnglish2, repeatUntilEventEnglish2, repeatPatternsEn, setPossessiveEnglish2, setPatternsEn, forEnglish2, ifEnglish2, unlessEnglish2, controlFlowPatternsEn, temporalInEnglish2, temporalAfterEnglish2, temporalPatternsEn, allEnglishOnlyPatterns, PATTERN_LOADERS, _generatedPatternsPerLanguage, handcraftedLanguages, patternCache2, _allPatterns, allPatterns, SemanticCache2, semanticCache, SemanticAnalyzerImpl, DEFAULT_CONFIDENCE_THRESHOLD, HIGH_CONFIDENCE_THRESHOLD, languageProfiles, schemaRegistry, DEFAULT_CONFIG, HIGH_FREQUENCY_TRIGGERS, THROTTLE_RECOMMENDED_TRIGGERS, _devModeEnabled, _devModeConfig, CONTEXT_VARS, LOGICAL_OPERATORS, BOOLEAN_LITERALS, TIME_UNITS, ExpressionParser, toggleMapper, addMapper, removeMapper, setMapper, showMapper, hideMapper, incrementMapper, decrementMapper, waitMapper, logMapper, putMapper, fetchMapper, appendMapper, prependMapper, triggerMapper, sendMapper, goMapper, transitionMapper, focusMapper, blurMapper, getMapper, takeMapper, callMapper, returnMapper, haltMapper, throwMapper, settleMapper, swapMapper, morphMapper, cloneMapper, makeMapper, measureMapper, tellMapper, jsMapper, asyncMapper, ifMapper, unlessMapper, repeatMapper, forMapper, whileMapper, continueMapper, defaultMapper, initMapper, behaviorMapper, installMapper, onMapper, mappers, ASTBuilder, LANGUAGE_IMPORTERS, SUPPORTED_LANGUAGES, VERSION, index, HistorySwapBehavior, BoostedBehavior, DEFAULT_EVENT_TYPE, DEFAULT_LANGUAGE$1, compileSyncFn, compileAsyncFn, getRuntimeFn, DEFAULT_LANGUAGE, ASTCache, astCache, semanticAnalyzerInstance, bridgeInstance, config, _defaultRuntime, hyperscript, lokascript, OP_TABLE, Lexer, Tokens, PropertyAccessInputSchema, PossessiveAccessInputSchema, AttributeAccessInputSchema, MyExpression, ItsExpression, AttributeExpression, MAX_HISTORY_SIZE$5, DefInputSchema, TypedDefFeatureImplementation, enhancedDefImplementation, MAX_HISTORY_SIZE$4, EnhancedOnInputSchema, TypedOnFeatureImplementation, enhancedOnImplementation, MAX_HISTORY_SIZE$3, BehaviorsInputSchema, TypedBehaviorsFeatureImplementation, enhancedBehaviorsImplementation, MAX_HISTORY_SIZE$2, SocketsInputSchema, TypedSocketsFeatureImplementation, enhancedSocketsImplementation, MAX_HISTORY_SIZE$1, WebWorkerInputSchema, TypedWebWorkerFeatureImplementation, enhancedWebWorkerImplementation, MAX_HISTORY_SIZE, EventSourceInputSchema, TypedEventSourceFeatureImplementation, enhancedEventSourceImplementation, POS, DiagnosticSeverity, SymbolKind, CompletionItemKind, _semanticModule, SemanticGrammarBridge, bridge;
+var KEYWORDS$2, COMMAND_TERMINATORS, COMMANDS, COMPOUND_COMMANDS, CONTROL_FLOW_COMMANDS, PUT_OPERATIONS, PUT_OPERATION_KEYWORDS, HYPERSCRIPT_KEYWORDS, CommandClassification, CSS_FUNCTIONS, CONTEXT_VARS$1, LOGICAL_OPERATORS$1, COMPARISON_OPERATORS, DOM_EVENTS, TOKENIZER_KEYWORDS, TokenKind, TokenType, KEYWORDS$1, MATHEMATICAL_OPERATORS, TIME_UNITS$1, isDebugEnabled$1, DEBUG, debug, debugEnabled, debugEventTarget, stats, DEFAULT_CONFIDENCE_THRESHOLD$1, SemanticIntegrationAdapter, MULTI_WORD_PATTERNS, DEFAULT_BOUNDARY_KEYWORDS, CommandNodeBuilder, SWAP_STRATEGY_KEYWORDS, Parser, HookRegistry, CleanupRegistry, sharedGlobals, EventSourceRegistry, ContextProviderRegistry, ExpressionTypeRegistry, expressionTypeRegistry, BOOLEAN_ATTRIBUTES, SPECIAL_DOM_PROPERTIES, BaseExpressionEvaluator, NUMBER_WORDS, isProduction, skipValidation, addDescribeToValidator, v, z, BaseExpressionImpl, MeExpression, YouExpression, ItExpression, CSSelectorInputSchema, CSSSelectorExpression, meExpression, youExpression, itExpression, itsExpression$1, resultExpression, querySelectorExpression, querySelectorAllExpression, idExpression, classExpression, closestExpression, parentExpression, windowExpression, documentExpression, elementWithSelectorExpression, styleRefExpression, possessiveStyleRefExpression, ofStyleRefExpression, referencesExpressions, LRUCache, HyperscriptCache, globalCache, PerformanceTracker, performanceTracker, cleanupInterval, BinaryLogicalInputSchema, UnaryLogicalInputSchema, AndExpression, OrExpression, NotExpression, ComparisonInputSchema, PatternMatchingInputSchema, equalsExpression, strictEqualsExpression, notEqualsExpression, strictNotEqualsExpression, lessThanExpression, lessThanOrEqualExpression, greaterThanExpression, greaterThanOrEqualExpression, andExpression, orExpression, notExpression, isEmptyExpression, noExpression, isNotEmptyExpression, existsExpression, doesNotExistExpression, containsExpression, doesNotContainExpression, startsWithExpression, endsWithExpression, matchesExpression, hasExpression, doesNotHaveExpression, logicalExpressions, enhancedConverters, AsExpressionInputSchema, AsExpression, IsExpressionInputSchema, IsExpression, defaultConversions, asExpression, isExpression, asyncExpression, conversionExpressions, evaluationToHyperScriptType, CollectionInputSchema, IndexInputSchema, RandomInputSchema, FirstExpression, LastExpression, AtExpression, RandomExpression, firstExpression, lastExpression, atExpression, nextExpression, previousExpression, nextWithinExpression, previousWithinExpression, positionalExpressions, UNSAFE_PROPS, possessiveExpression, myExpression, itsExpression, yourExpression, ofExpression, attributeExpression, attributeWithValueExpression, classReferenceExpression, idReferenceExpression, propertiesExpressions, StringLiteralInputSchema, NumberLiteralInputSchema, BooleanLiteralInputSchema, BinaryOperationInputSchema, StringLiteralExpression, NumberLiteralExpression, BooleanLiteralExpression, AdditionExpression, StringConcatenationExpression, MultiplicationExpression, specialExpressions, ExpressionEvaluator, ContextBridge, CommandAdapterV2, CommandRegistryV2, defaultRegistry, RegistryIntegration, eventRecursionDepth, RuntimeBase, COMMAND_NAME, COMMAND_CATEGORY, COMMAND_METADATA, KEYWORD_PREPOSITIONS, VisibilityCommandBase, HideCommand, createHideCommand, ShowCommand, createShowCommand, SMART_ELEMENT_TAGS, DOMModificationBase, AddCommand, createAddCommand, RemoveCommand, createRemoveCommand, PATTERN, BOOL_PROPS, ToggleCommand, createToggleCommand, PutCommand, createPutCommand, MakeCommand, createMakeCommand, SUPPORTS_MOVE_BEFORE, ELEMENT_NODE_TYPE, TEXT_NODE_TYPE, IS_PARENT_NODE_TYPE, Operation, candidateNodes, candidateElements, candidateElementsWithIds, unmatchedNodes, unmatchedElements, whitespaceNodes, _idArrayMap, _idSetMap, _options, _Morph_instances, morphOneToMany_fn, morphOneToOne_fn, morphMatchingElements_fn, morphNonMatchingElements_fn, morphOtherNode_fn, visitAttributes_fn, visitTextArea_fn, replaceNode_fn, removeNode_fn, mapIdArraysForEach_fn, mapIdArrays_fn, mapIdSets_fn, Morph, morphlexMorph, morphlexMorphInner, morphlexEngine, currentEngine, morphAdapter, config$1, transitionQueue, isProcessingQueue, CRITICAL_LAYOUT_ELEMENTS, STRUCTURAL_SEMANTIC_ELEMENTS, WARNING_ELEMENTS, DEFAULT_VALIDATION_CONFIG, globalConfig, STYLES, SEVERITY_ICONS, SEVERITY_LABELS, STRATEGY_KEYWORDS, SwapCommand, MorphCommand, createSwapCommand, createMorphCommand, STRATEGY_MAP, ProcessPartialsCommand, createProcessPartialsCommand, WaitCommand, createWaitCommand, customResponseTypes, FetchCommand, createFetchCommand, SetCommand, createSetCommand, GetCommand, createGetCommand, NumericModifyCommand, createIncrementCommand, createDecrementCommand, LogCommand, createLogCommand, EventDispatchCommand, createTriggerCommand, createSendCommand, GoCommand, createGoCommand, KEYWORDS, HistoryCommand, createPushUrlCommand, createReplaceUrlCommand, ConditionalCommand, createConditionalCommand, createIfCommand, createUnlessCommand, RepeatCommand, createRepeatCommand, ControlFlowSignalBase, BreakCommand, createBreakCommand, ContinueCommand, createContinueCommand, HaltCommand, createHaltCommand, ReturnCommand, createReturnCommand, ExitCommand, createExitCommand, CallCommand, createCallCommand, AppendCommand, createAppendCommand, TransitionCommand, createTransitionCommand, MeasureCommand, createMeasureCommand, SettleCommand, createSettleCommand, JsCommand, createJsCommand, AsyncCommand, createAsyncCommand, DefaultCommand, createDefaultCommand, PseudoCommand, TellCommand, createTellCommand, CopyCommand, createCopyCommand, PickCommand, createPickCommand, ThrowCommand, createThrowCommand, BeepCommand, createBeepCommand, InstallCommand, TakeCommand, createTakeCommand, RenderCommand, Runtime, DebugLogger, _PatternMatcher$1, PatternMatcher$1, StringLiteralExtractor, NumberExtractor, IdentifierExtractor, DEFAULT_REFERENCES, STRUCTURAL_ROLES, TokenStreamImpl, DEFAULT_OPERATORS$1, _BaseTokenizer, BaseTokenizer, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __esm2, __export2, __copyProps2, __toCommonJS2, tokenizers, profiles, patternCache, patternGenerator, registeredPatterns, init_registry, init_token_utils, init_char_classifiers, init_base_tokenizer, init_base, init_types, COMBINED_PREFIXES, SINGLE_PREFIXES, VERB_PREFIXES, SUFFIXES, ArabicMorphologicalNormalizer, init_arabic_normalizer, arabic_exports, arabicProfile, init_arabic, DEFAULT_OPERATORS, OperatorExtractor, DEFAULT_PUNCTUATION, PunctuationExtractor, init_generic_extractors, CssSelectorExtractor, init_css_selector, EventModifierExtractor, init_event_modifier, UrlExtractor, init_url, VariableRefExtractor, init_variable_ref, JapaneseKeywordExtractor, init_japanese_keyword, SINGLE_CHAR_PARTICLES, MULTI_CHAR_PARTICLES, JapaneseParticleExtractor, init_japanese_particle, TEMPORAL_EVENT_SUFFIXES, KoreanKeywordExtractor, init_korean_keyword, SINGLE_CHAR_PARTICLES2, MULTI_CHAR_PARTICLES2, KoreanParticleExtractor, init_korean_particle, ChineseKeywordExtractor, init_chinese_keyword, SINGLE_CHAR_PARTICLES3, MULTI_CHAR_PARTICLES3, ChineseParticleExtractor, init_chinese_particle, isVietnameseLetter, isVietnameseIdentifierChar, PREPOSITIONS, VietnameseKeywordExtractor, init_vietnamese_keyword, isArabic2, PREPOSITIONS2, ArabicKeywordExtractor, init_arabic_keyword, isArabic3, PROCLITICS, ArabicProcliticExtractor, init_arabic_proclitic, isArabic4, TEMPORAL_MARKERS, ArabicTemporalExtractor, init_arabic_temporal, CyrillicKeywordExtractor, RUSSIAN_PREPOSITIONS, UKRAINIAN_PREPOSITIONS, init_cyrillic_keyword, HindiKeywordExtractor, init_hindi_keyword, SINGLE_POSTPOSITIONS, COMPOUND_POSTPOSITIONS, HindiParticleExtractor, init_hindi_particle, BengaliKeywordExtractor, init_bengali_keyword, SINGLE_POSTPOSITIONS2, BengaliParticleExtractor, init_bengali_particle, ThaiKeywordExtractor, init_thai_keyword, MalayKeywordExtractor, init_malay_keyword, PREPOSITIONS3, TagalogKeywordExtractor, init_tagalog_keyword, PREPOSITIONS4, isPolishLetter, isPolishIdentifierChar, PolishKeywordExtractor, init_polish_keyword, PREPOSITIONS5, isIndonesianLetter, isIndonesianIdentifierChar, IndonesianKeywordExtractor, init_indonesian_keyword, PREPOSITIONS6, isSwahiliLetter, isSwahiliIdentifierChar, SwahiliKeywordExtractor, init_swahili_keyword, POSTPOSITIONS, CASE_SUFFIXES, TurkishKeywordExtractor, init_turkish_keyword, SUFFIXES2, POSTPOSITIONS2, QuechuaKeywordExtractor, init_quechua_keyword, isHebrew, PREPOSITIONS7, CONJUNCTIONS, HebrewKeywordExtractor, init_hebrew_keyword, isHebrew2, PROCLITIC_PREFIXES, EVENT_MARKER_PREFIXES, EVENT_NAMES, HebrewProcliticExtractor, init_hebrew_proclitic, AsciiIdentifierExtractor, init_ascii_identifier, init_extractors, init_extractor_helpers, arabic_exports2, CONJUNCTIONS2, PREPOSITIONS8, ARABIC_EXTRAS, ArabicTokenizer, arabicTokenizer, init_arabic2, SUFFIX_RULES, BengaliMorphologicalNormalizer, bengaliMorphologicalNormalizer, init_bengali_normalizer, bengali_exports, bengaliProfile, init_bengali, bengali_exports2, SINGLE_POSTPOSITIONS3, BENGALI_EXTRAS, BengaliTokenizer, bengaliTokenizer, init_bengali2, german_exports, germanProfile, init_german, SEPARABLE_PREFIXES, VERB_ENDINGS, ELN_ERN_ENDINGS, ALL_ENDINGS, GermanMorphologicalNormalizer, init_german_normalizer, isGermanLetter, isGermanIdentifierChar, PREPOSITIONS9, GermanKeywordExtractor, init_german_keyword, german_exports2, GERMAN_EXTRAS, GermanTokenizer, germanTokenizer, init_german2, english_exports, englishProfile, init_english, EnglishKeywordExtractor, init_english_keyword, english_exports2, ENGLISH_EXTRAS, EnglishTokenizer, englishTokenizer, init_english2, SchemaErrorCodes, SchemaErrorMessages, SchemaErrorSuggestions, init_schema_error_codes, schema_validator_exports, MULTI_TYPE_PATIENT_COMMANDS, NO_REQUIRED_ROLES_COMMANDS, init_schema_validator, toggleSchema, addSchema, removeSchema, putSchema, setSchema, showSchema, hideSchema, onSchema, triggerSchema, waitSchema, fetchSchema, incrementSchema, decrementSchema, appendSchema, prependSchema, logSchema, getCommandSchema, takeSchema, makeSchema, haltSchema, settleSchema, throwSchema, sendSchema, ifSchema, unlessSchema, elseSchema, repeatSchema, forSchema, whileSchema, continueSchema, goSchema, transitionSchema, cloneSchema, focusSchema, blurSchema, callSchema, returnSchema, jsSchema, asyncSchema, tellSchema, defaultSchema, initSchema, behaviorSchema, installSchema, measureSchema, swapSchema, morphSchema, beepSchema, breakSchema, copySchema, exitSchema, pickSchema, renderSchema, commandSchemas, init_command_schemas, init_role_positioning, init_marker_resolution, init_event_handlers_sov, init_event_handlers_vso, defaultConfig, init_pattern_generator, init_en, init_en2, init_en3, en_exports, fetchWithResponseTypeEnglish, fetchSimpleEnglish, swapSimpleEnglish, repeatUntilEventFromEnglish, repeatUntilEventEnglish, setPossessiveEnglish, forEnglish, ifEnglish, unlessEnglish, temporalInEnglish, temporalAfterEnglish, init_en4, REFLEXIVE_SUFFIXES, AR_ENDINGS, ER_ENDINGS, IR_ENDINGS, ALL_ENDINGS2, SpanishMorphologicalNormalizer, init_spanish_normalizer, spanish_exports, spanishProfile, init_spanish, isSpanishLetter, isSpanishIdentifierChar, PREPOSITIONS10, SpanishKeywordExtractor, init_spanish_keyword, spanish_exports2, PREPOSITIONS11, SPANISH_EXTRAS, SpanishTokenizer, spanishTokenizer, init_spanish2, french_exports, frenchProfile, init_french, REFLEXIVE_SUFFIXES2, ER_ENDINGS2, IR_ENDINGS2, RE_ENDINGS, ALL_ENDINGS3, FrenchMorphologicalNormalizer, init_french_normalizer, isFrenchLetter, isFrenchIdentifierChar, PREPOSITIONS12, FrenchKeywordExtractor, init_french_keyword, french_exports2, FRENCH_EXTRAS, FrenchTokenizer, frenchTokenizer, init_french2, hebrewProfile, init_hebrew, PREPOSITIONS13, HEBREW_EXTRAS, HebrewTokenizer, hebrewTokenizer, init_he, SUFFIX_RULES2, HindiMorphologicalNormalizer, init_hindi_normalizer, hindi_exports, hindiProfile, init_hindi, hindi_exports2, SINGLE_POSTPOSITIONS4, HINDI_EXTRAS, HindiTokenizer, hindiTokenizer, init_hindi2, indonesian_exports, indonesianProfile, init_indonesian, indonesian_exports2, PREPOSITIONS14, INDONESIAN_EXTRAS, IndonesianTokenizer, indonesianTokenizer, init_indonesian2, REFLEXIVE_SUFFIXES3, ARE_ENDINGS, ERE_ENDINGS, IRE_ENDINGS, ALL_ENDINGS4, ItalianMorphologicalNormalizer, init_italian_normalizer, italian_exports, italianProfile, init_italian, RomanceKeywordExtractor, ITALIAN_PREPOSITIONS, init_romance_language_keyword, italian_exports2, PREPOSITIONS15, ITALIAN_EXTRAS, ItalianTokenizer, italianTokenizer, init_italian2, JAPANESE_SUFFIX_RULES, SURU_PATTERNS, JapaneseMorphologicalNormalizer, init_japanese_normalizer, japanese_exports, japaneseProfile, init_japanese, japanese_exports2, PARTICLES, JAPANESE_EXTRAS, JapaneseTokenizer, japaneseTokenizer, init_japanese2, KOREAN_SUFFIX_RULES, HADA_PATTERNS, KoreanMorphologicalNormalizer, init_korean_normalizer, korean_exports, koreanProfile, init_korean, korean_exports2, PARTICLES2, KOREAN_EXTRAS, KoreanTokenizer, koreanTokenizer, init_korean2, ms_exports, malayProfile, init_ms, ms_exports2, MALAY_EXTRAS, MalayTokenizer, malayTokenizer, init_ms2, polish_exports, polishProfile, init_polish, IMPERATIVE_TO_INFINITIVE, PolishMorphologicalNormalizer, init_polish_normalizer, polish_exports2, PREPOSITIONS16, POLISH_EXTRAS, PolishTokenizer, polishTokenizer, init_polish2, portuguese_exports, portugueseProfile, init_portuguese, REFLEXIVE_SUFFIXES4, AR_ENDINGS2, ER_ENDINGS3, IR_ENDINGS3, ALL_ENDINGS5, PortugueseMorphologicalNormalizer, init_portuguese_normalizer, isPortugueseLetter, isPortugueseIdentifierChar, PREPOSITIONS17, PortugueseKeywordExtractor, init_portuguese_keyword, portuguese_exports2, PREPOSITIONS18, PORTUGUESE_EXTRAS, PortugueseTokenizer, portugueseTokenizer, init_portuguese2, quechua_exports, quechuaProfile, init_quechua, QUECHUA_SUFFIX_RULES, QuechuaMorphologicalNormalizer, quechuaMorphologicalNormalizer, init_quechua_normalizer, quechua_exports2, QuechuaStringLiteralExtractor, SUFFIXES3, QUECHUA_EXTRAS, QuechuaTokenizer, quechuaTokenizer, init_quechua2, IMPERATIVE_TO_INFINITIVE2, RussianMorphologicalNormalizer, init_russian_normalizer, russian_exports, russianProfile, init_russian, russian_exports2, PREPOSITIONS19, RUSSIAN_EXTRAS, RussianTokenizer, russianTokenizer, init_russian2, swahili_exports, swahiliProfile, init_swahili, swahili_exports2, PREPOSITIONS20, SWAHILI_EXTRAS, SwahiliTokenizer, swahiliTokenizer, init_swahili2, thai_exports, thaiProfile, init_thai, thai_exports2, THAI_EXTRAS, ThaiTokenizer, thaiTokenizer, init_thai2, tl_exports, tagalogProfile, init_tl, COMBINED_PREFIXES2, SINGLE_PREFIXES2, INFIXES, SUFFIXES4, TagalogMorphologicalNormalizer, tagalogMorphologicalNormalizer, init_tagalog_normalizer, tl_exports2, TAGALOG_EXTRAS, TagalogTokenizer, tagalogTokenizer, init_tl2, TURKISH_SUFFIX_RULES, TurkishMorphologicalNormalizer, init_turkish_normalizer, turkish_exports, turkishProfile, init_turkish, turkish_exports2, POSTPOSITIONS3, CASE_SUFFIXES2, TURKISH_EXTRAS, TurkishTokenizer, turkishTokenizer, init_turkish2, IMPERATIVE_TO_INFINITIVE3, UkrainianMorphologicalNormalizer, init_ukrainian_normalizer, ukrainian_exports, ukrainianProfile, init_ukrainian, ukrainian_exports2, PREPOSITIONS21, UKRAINIAN_EXTRAS, UkrainianTokenizer, ukrainianTokenizer, init_ukrainian2, vietnamese_exports, vietnameseProfile, init_vietnamese, vietnamese_exports2, VIETNAMESE_EXTRAS, VietnameseTokenizer, vietnameseTokenizer, init_vietnamese2, chinese_exports, chineseProfile, init_chinese, chinese_exports2, PARTICLES3, CHINESE_EXTRAS, ChineseTokenizer, chineseTokenizer, init_chinese2, init_types2, eventNameTranslations, init_shared, init_tokenizers, init_type_validation, init_possessive_keywords, _PatternMatcher2, PatternMatcher, patternMatcher, init_pattern_matcher, SemanticRendererImpl, semanticRenderer, init_renderer, hyperscriptSchemaLookup, init_parser, semantic_parser_exports, _SemanticParserImpl, SemanticParserImpl, semanticParser, init_semantic_parser, spanishMexicoProfile, fetchWithResponseTypeEnglish2, fetchSimpleEnglish2, fetchPatternsEn, swapSimpleEnglish2, swapPatternsEn, repeatUntilEventFromEnglish2, repeatUntilEventEnglish2, repeatPatternsEn, setPossessiveEnglish2, setPatternsEn, forEnglish2, ifEnglish2, unlessEnglish2, controlFlowPatternsEn, temporalInEnglish2, temporalAfterEnglish2, temporalPatternsEn, allEnglishOnlyPatterns, PATTERN_LOADERS, _generatedPatternsPerLanguage, handcraftedLanguages, patternCache2, _allPatterns, allPatterns, SemanticCache2, semanticCache, SemanticAnalyzerImpl, DEFAULT_CONFIDENCE_THRESHOLD, HIGH_CONFIDENCE_THRESHOLD, languageProfiles, schemaRegistry, DEFAULT_CONFIG, HIGH_FREQUENCY_TRIGGERS, THROTTLE_RECOMMENDED_TRIGGERS, _devModeEnabled, _devModeConfig, CONTEXT_VARS, LOGICAL_OPERATORS, BOOLEAN_LITERALS, TIME_UNITS, ExpressionParser, toggleMapper, addMapper, removeMapper, setMapper, showMapper, hideMapper, incrementMapper, decrementMapper, waitMapper, logMapper, putMapper, fetchMapper, appendMapper, prependMapper, triggerMapper, sendMapper, goMapper, transitionMapper, focusMapper, blurMapper, getMapper, takeMapper, callMapper, returnMapper, haltMapper, throwMapper, settleMapper, swapMapper, morphMapper, cloneMapper, makeMapper, measureMapper, tellMapper, jsMapper, asyncMapper, ifMapper, unlessMapper, repeatMapper, forMapper, whileMapper, continueMapper, defaultMapper, initMapper, behaviorMapper, installMapper, onMapper, mappers, ASTBuilder, LANGUAGE_IMPORTERS, SUPPORTED_LANGUAGES, VERSION, index, HistorySwapBehavior, BoostedBehavior, DEFAULT_EVENT_TYPE, DEFAULT_LANGUAGE$1, compileSyncFn, compileAsyncFn, getRuntimeFn, RingBuffer, HISTORY_CAPACITY, DebugController, DEFAULT_LANGUAGE, ASTCache, astCache, semanticAnalyzerInstance, bridgeInstance, config, _defaultRuntime, _debugController, hyperscript, lokascript, OP_TABLE, Lexer, Tokens, PropertyAccessInputSchema, PossessiveAccessInputSchema, AttributeAccessInputSchema, MyExpression, ItsExpression, AttributeExpression, MAX_HISTORY_SIZE$5, DefInputSchema, TypedDefFeatureImplementation, enhancedDefImplementation, MAX_HISTORY_SIZE$4, EnhancedOnInputSchema, TypedOnFeatureImplementation, enhancedOnImplementation, MAX_HISTORY_SIZE$3, BehaviorsInputSchema, TypedBehaviorsFeatureImplementation, enhancedBehaviorsImplementation, MAX_HISTORY_SIZE$2, SocketsInputSchema, TypedSocketsFeatureImplementation, enhancedSocketsImplementation, MAX_HISTORY_SIZE$1, WebWorkerInputSchema, TypedWebWorkerFeatureImplementation, enhancedWebWorkerImplementation, MAX_HISTORY_SIZE, EventSourceInputSchema, TypedEventSourceFeatureImplementation, enhancedEventSourceImplementation, POS, DiagnosticSeverity, SymbolKind, CompletionItemKind, _semanticModule, SemanticGrammarBridge, bridge;
 var init_dist = __esm({
   "../core/dist/index.mjs"() {
     "use strict";
@@ -22906,31 +23245,7 @@ var init_dist = __esm({
                 }
               }
             }
-            const handlerCommands = [];
-            while (!this.isAtEnd() && !this.check("end")) {
-              if (this.checkIsCommand() || this.isCommand(this.peek().value)) {
-                this.advance();
-                const savedError = this.error;
-                try {
-                  const cmd = this.parseCommand();
-                  if (this.error && this.error !== savedError) {
-                    this.error = savedError;
-                  }
-                  handlerCommands.push(cmd);
-                  while (!this.isAtEnd() && !this.check("end") && !this.checkIsCommand() && !this.isCommand(this.peek().value)) {
-                    this.advance();
-                  }
-                } catch (error) {
-                  this.error = savedError;
-                  break;
-                }
-              } else {
-                if (!this.check("end")) {
-                  this.addError(`Unexpected token in event handler: ${this.peek().value}`);
-                }
-                break;
-              }
-            }
+            const handlerCommands = this.parseCommandListUntilEnd();
             const handlerNode = {
               type: "eventHandler",
               event: eventName,
@@ -22943,7 +23258,6 @@ var init_dist = __esm({
               column: handlerPos.column
             };
             eventHandlers.push(handlerNode);
-            this.consume("end", "Expected 'end' after event handler body");
           } else if (this.match("init")) {
             const initCommands = this.parseCommandBlock(["end"]);
             initBlock = {
@@ -24615,8 +24929,9 @@ var init_dist = __esm({
       outerhtml: (el) => el.outerHTML,
       value: (el) => isFormElement(el) ? el.value : void 0,
       checked: (el) => isInputElement$1(el) ? el.checked : void 0,
-      disabled: (el) => isFormElement(el) ? el.disabled : void 0,
+      disabled: (el) => "disabled" in el ? el.disabled : void 0,
       selected: (el) => isOptionElement$1(el) ? el.selected : void 0,
+      tabindex: (el) => isHTMLElement$2(el) ? el.tabIndex : void 0,
       hidden: (el) => isHTMLElement$2(el) ? el.hidden : void 0,
       style: (el) => getComputedStyle(el),
       children: (el) => Array.from(el.children),
@@ -29906,14 +30221,31 @@ var init_dist = __esm({
       }
       async executeBehaviorDefinition(node, _context) {
         const { name, parameters, eventHandlers, initBlock } = node;
-        this.behaviorRegistry.set(name, { name, parameters, eventHandlers, initBlock });
-        debug.runtime(`RUNTIME BASE: Registered behavior '${name}'`);
+        const imperativeInstaller = node.imperativeInstaller;
+        if (typeof imperativeInstaller === "function") {
+          this.behaviorRegistry.set(name, {
+            name,
+            parameters,
+            type: "imperative",
+            install: imperativeInstaller
+          });
+          debug.runtime(`RUNTIME BASE: Registered imperative behavior '${name}'`);
+        } else {
+          this.behaviorRegistry.set(name, { name, parameters, eventHandlers, initBlock });
+          debug.runtime(`RUNTIME BASE: Registered behavior '${name}'`);
+        }
       }
       async installBehaviorOnElement(behaviorName, element, parameters) {
         debug.runtime(`BEHAVIOR: installBehaviorOnElement called: ${behaviorName}`);
         const behavior = this.behaviorRegistry.get(behaviorName);
         if (!behavior)
           throw new Error(`Behavior "${behaviorName}" not found`);
+        if (behavior.type === "imperative" && typeof behavior.install === "function") {
+          debug.runtime(`BEHAVIOR: Installing imperative behavior '${behaviorName}'`);
+          behavior.install(element, parameters);
+          debug.runtime(`BEHAVIOR: Finished installing imperative behavior '${behaviorName}'`);
+          return;
+        }
         debug.runtime(`BEHAVIOR: Found behavior, eventHandlers count: ${behavior.eventHandlers?.length || 0}`);
         const baseBehaviorContext = {
           me: element,
@@ -31296,6 +31628,7 @@ var init_dist = __esm({
     };
     candidateNodes = /* @__PURE__ */ new Set();
     candidateElements = /* @__PURE__ */ new Set();
+    candidateElementsWithIds = /* @__PURE__ */ new Set();
     unmatchedNodes = /* @__PURE__ */ new Set();
     unmatchedElements = /* @__PURE__ */ new Set();
     whitespaceNodes = /* @__PURE__ */ new Set();
@@ -31327,6 +31660,7 @@ var init_dist = __esm({
         const toChildNodes = [...to.childNodes];
         candidateNodes.clear();
         candidateElements.clear();
+        candidateElementsWithIds.clear();
         unmatchedNodes.clear();
         unmatchedElements.clear();
         whitespaceNodes.clear();
@@ -31342,7 +31676,11 @@ var init_dist = __esm({
           candidateNodeTypeMap[i] = nodeType;
           if (nodeType === ELEMENT_NODE_TYPE) {
             candidateLocalNameMap[i] = candidate.localName;
-            candidateElements.add(i);
+            if (candidate.id !== "") {
+              candidateElementsWithIds.add(i);
+            } else {
+              candidateElements.add(i);
+            }
           } else if (nodeType === TEXT_NODE_TYPE && candidate.textContent?.trim() === "") {
             whitespaceNodes.add(i);
           } else {
@@ -31385,13 +31723,13 @@ var init_dist = __esm({
           if (id === "" && !idArray)
             continue;
           candidateLoop:
-            for (const candidateIndex of candidateElements) {
+            for (const candidateIndex of candidateElementsWithIds) {
               const candidate = fromChildNodes[candidateIndex];
               if (localNameMap[unmatchedIndex] === candidateLocalNameMap[candidateIndex]) {
                 if (id !== "" && id === candidate.id) {
                   matches[unmatchedIndex] = candidateIndex;
                   op[unmatchedIndex] = Operation.SameElement;
-                  candidateElements.delete(candidateIndex);
+                  candidateElementsWithIds.delete(candidateIndex);
                   unmatchedElements.delete(unmatchedIndex);
                   break candidateLoop;
                 }
@@ -31403,7 +31741,7 @@ var init_dist = __esm({
                       if (candidateIdSet.has(arrayId)) {
                         matches[unmatchedIndex] = candidateIndex;
                         op[unmatchedIndex] = Operation.SameElement;
-                        candidateElements.delete(candidateIndex);
+                        candidateElementsWithIds.delete(candidateIndex);
                         unmatchedElements.delete(unmatchedIndex);
                         break candidateLoop;
                       }
@@ -31478,6 +31816,8 @@ var init_dist = __esm({
           __privateMethod(this, _Morph_instances, removeNode_fn).call(this, fromChildNodes[i]);
         for (const i of candidateElements)
           __privateMethod(this, _Morph_instances, removeNode_fn).call(this, fromChildNodes[i]);
+        for (const i of candidateElementsWithIds)
+          __privateMethod(this, _Morph_instances, removeNode_fn).call(this, fromChildNodes[i]);
         const lisIndices = longestIncreasingSubsequence(matches);
         const shouldNotMove = new Array(fromChildNodes.length);
         for (let i = 0; i < lisIndices.length; i++) {
@@ -36243,7 +36583,7 @@ var init_dist = __esm({
        * a token and the immediately following pattern token fails, the matcher
        * resets to before the optional role and retries the failed token.
        */
-      matchTokenSequence(tokens, patternTokens, captured) {
+      matchTokenSequence(tokens, patternTokens, captured, parentStopMarkers) {
         const firstPatternToken = patternTokens[0];
         const patternExpectsConjunction = firstPatternToken?.type === "literal" && (firstPatternToken.value === "and" || firstPatternToken.value === "then" || firstPatternToken.alternatives?.includes("and") || firstPatternToken.alternatives?.includes("then"));
         if (this.currentProfile?.code === "ar" && !patternExpectsConjunction) {
@@ -36267,6 +36607,9 @@ var init_dist = __esm({
           );
           if (patternToken.type === "role" && patternToken.greedy) {
             const stopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+            if (parentStopMarkers) {
+              for (const m of parentStopMarkers) stopMarkers.add(m);
+            }
             const values = [];
             while (!tokens.isAtEnd()) {
               const nextToken = tokens.peek();
@@ -36286,8 +36629,58 @@ var init_dist = __esm({
               return false;
             }
           }
+          if (patternToken.type === "group") {
+            const siblingStopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+            if (parentStopMarkers) {
+              for (const m of parentStopMarkers) siblingStopMarkers.add(m);
+            }
+            const groupMatched = this.matchGroupToken(
+              tokens,
+              patternToken,
+              captured,
+              siblingStopMarkers
+            );
+            if (groupMatched) {
+              prevOptionalMark = null;
+              prevOptionalRole = null;
+              continue;
+            }
+            if (this.isOptional(patternToken)) {
+              continue;
+            }
+            return false;
+          }
           const isOptionalRole = patternToken.type === "role" && patternToken.optional === true;
           const markBefore = isOptionalRole ? tokens.mark() : null;
+          const isRoleToken = patternToken.type === "role";
+          if (isRoleToken && !isOptionalRole) {
+            const nextPT = i + 1 < patternTokens.length ? patternTokens[i + 1] : null;
+            if (nextPT?.type === "literal") {
+              const currentToken = tokens.peek();
+              if (currentToken && this.getMatchType(currentToken, nextPT.value) !== "none") {
+                this.logger.debug(
+                  "  >> MARKER-STEAL GUARD: current token matches next literal, skipping role"
+                );
+                this.logger.debug("  >> Token match FAILED");
+                if (this.isOptional(patternToken)) {
+                  continue;
+                }
+                if (prevOptionalMark && prevOptionalRole) {
+                  this.logger.debug("  >> BACKTRACKING: undoing optional role", prevOptionalRole);
+                  tokens.reset(prevOptionalMark);
+                  captured.delete(prevOptionalRole);
+                  prevOptionalMark = null;
+                  prevOptionalRole = null;
+                  const retryMatched = this.matchPatternToken(tokens, patternToken, captured);
+                  this.logger.debug("  >> Backtrack retry result:", retryMatched);
+                  if (retryMatched) {
+                    continue;
+                  }
+                }
+                return false;
+              }
+            }
+          }
           const matched = this.matchPatternToken(tokens, patternToken, captured);
           this.logger.debug("  >> Match result:", matched);
           if (matched) {
@@ -36408,7 +36801,7 @@ var init_dist = __esm({
         const possessiveValue = this.tryMatchPossessiveExpression(tokens);
         if (possessiveValue) {
           if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-            if (!patternToken.expectedTypes.includes(possessiveValue.type) && !patternToken.expectedTypes.includes("expression")) {
+            if (!isTypeCompatible$1(possessiveValue.type, patternToken.expectedTypes)) {
               return patternToken.optional || false;
             }
           }
@@ -36418,7 +36811,7 @@ var init_dist = __esm({
         const methodCallValue = this.tryMatchMethodCallExpression(tokens);
         if (methodCallValue) {
           if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-            if (!patternToken.expectedTypes.includes(methodCallValue.type) && !patternToken.expectedTypes.includes("expression")) {
+            if (!isTypeCompatible$1(methodCallValue.type, patternToken.expectedTypes)) {
               return patternToken.optional || false;
             }
           }
@@ -36438,7 +36831,7 @@ var init_dist = __esm({
         const propertyAccessValue = this.tryMatchPropertyAccessExpression(tokens);
         if (propertyAccessValue) {
           if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-            if (!patternToken.expectedTypes.includes(propertyAccessValue.type) && !patternToken.expectedTypes.includes("expression")) {
+            if (!isTypeCompatible$1(propertyAccessValue.type, patternToken.expectedTypes)) {
               return patternToken.optional || false;
             }
           }
@@ -36757,10 +37150,15 @@ var init_dist = __esm({
        * (e.g., a value like 'hello') to sit between groups without blocking later
        * marker matches.
        */
-      matchGroupToken(tokens, patternToken, captured) {
+      matchGroupToken(tokens, patternToken, captured, parentStopMarkers) {
         const mark = tokens.mark();
         const capturedBefore = new Set(captured.keys());
-        const success2 = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+        const success2 = this.matchTokenSequence(
+          tokens,
+          patternToken.tokens,
+          captured,
+          parentStopMarkers
+        );
         if (success2) return true;
         tokens.reset(mark);
         for (const role of captured.keys()) {
@@ -36782,7 +37180,12 @@ var init_dist = __esm({
                 "- skipping intervening tokens"
               );
               for (let s = 0; s < offset; s++) tokens.advance();
-              const retrySuccess = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+              const retrySuccess = this.matchTokenSequence(
+                tokens,
+                patternToken.tokens,
+                captured,
+                parentStopMarkers
+              );
               if (retrySuccess) return true;
               tokens.reset(mark);
               for (const role of captured.keys()) {
@@ -36849,7 +37252,7 @@ var init_dist = __esm({
                 break;
               }
             }
-            break;
+            if (!pt.optional) break;
           }
         }
         return markers;
@@ -36859,8 +37262,9 @@ var init_dist = __esm({
        */
       isStopMarker(token, stopMarkers) {
         if (stopMarkers.size === 0) return false;
-        const value = (token.normalized || token.value).toLowerCase();
-        return stopMarkers.has(value);
+        if (stopMarkers.has(token.value.toLowerCase())) return true;
+        if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
+        return false;
       }
       /**
        * Convert a language token to a semantic value.
@@ -37329,6 +37733,27 @@ var init_dist = __esm({
         } : null;
       }
     };
+    DEFAULT_REFERENCES = /* @__PURE__ */ new Set([
+      "me",
+      "you",
+      "it",
+      "result",
+      "event",
+      "target",
+      "body"
+    ]);
+    STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+      "body",
+      "then",
+      "else",
+      "condition",
+      "loop-body",
+      "variable",
+      "catch",
+      // v1.2: try/catch/finally
+      "finally"
+      // v1.2: try/catch/finally
+    ]);
     TokenStreamImpl = class {
       constructor(tokens, language) {
         this.pos = 0;
@@ -42775,6 +43200,10 @@ var init_dist = __esm({
           // Loop commands
           FOR_LOOP_MISSING_SOURCE: "SCHEMA_FOR_LOOP_MISSING_SOURCE",
           WHILE_LOOP_MISSING_CONDITION: "SCHEMA_WHILE_LOOP_MISSING_CONDITION",
+          // Type constraint issues (v1.2)
+          VALUE_TYPE_MISMATCH: "SCHEMA_VALUE_TYPE_MISMATCH",
+          SELECTOR_KIND_MISMATCH: "SCHEMA_SELECTOR_KIND_MISMATCH",
+          SELECTOR_KINDS_WITHOUT_SELECTOR_TYPE: "SCHEMA_SELECTOR_KINDS_WITHOUT_SELECTOR_TYPE",
           // Keyword collision
           KEYWORD_COLLISION: "PROFILE_KEYWORD_COLLISION"
         };
@@ -42798,6 +43227,10 @@ var init_dist = __esm({
           // Loops
           [SchemaErrorCodes.FOR_LOOP_MISSING_SOURCE]: "For-loop should have a 'source' role for the collection to iterate over.",
           [SchemaErrorCodes.WHILE_LOOP_MISSING_CONDITION]: "While-loop should have a 'condition' role for the loop condition.",
+          // Type constraint (v1.2)
+          [SchemaErrorCodes.VALUE_TYPE_MISMATCH]: "Role '{role}' of command '{command}' expects type [{expectedTypes}], got '{actualType}'.",
+          [SchemaErrorCodes.SELECTOR_KIND_MISMATCH]: "Role '{role}' of command '{command}' expects selector kind [{selectorKinds}], got '{actualKind}'.",
+          [SchemaErrorCodes.SELECTOR_KINDS_WITHOUT_SELECTOR_TYPE]: "Role '{role}' has selectorKinds but expectedTypes does not include 'selector'.",
           // Keyword collision
           [SchemaErrorCodes.KEYWORD_COLLISION]: "Keyword '{keyword}' is used by multiple commands: {commands}. Only the first-registered command will be reachable."
         };
@@ -42812,6 +43245,9 @@ var init_dist = __esm({
           [SchemaErrorCodes.CONDITIONAL_CONDITION_NOT_REQUIRED]: "Set required: true on the 'condition' role.",
           [SchemaErrorCodes.FOR_LOOP_MISSING_SOURCE]: "Add a 'source' role for the collection to iterate over.",
           [SchemaErrorCodes.WHILE_LOOP_MISSING_CONDITION]: "Add a 'condition' role for the loop continuation condition.",
+          [SchemaErrorCodes.VALUE_TYPE_MISMATCH]: "Ensure the value matches one of the expected types: [{expectedTypes}].",
+          [SchemaErrorCodes.SELECTOR_KIND_MISMATCH]: "Use a selector of the correct kind: [{selectorKinds}].",
+          [SchemaErrorCodes.SELECTOR_KINDS_WITHOUT_SELECTOR_TYPE]: "Either add 'selector' to expectedTypes or remove selectorKinds.",
           [SchemaErrorCodes.KEYWORD_COLLISION]: "Give each command a unique keyword. Move the shared keyword to alternatives on one command, or use a more specific translation."
         };
       }
@@ -42824,7 +43260,8 @@ var init_dist = __esm({
       validateAllKeywordCollisions: () => validateAllKeywordCollisions,
       validateAllSchemas: () => validateAllSchemas,
       validateCommandSchema: () => validateCommandSchema,
-      validateKeywordCollisions: () => validateKeywordCollisions
+      validateKeywordCollisions: () => validateKeywordCollisions,
+      validateRoleValues: () => validateRoleValues
     });
     init_schema_validator = __esm2({
       "src/generators/schema-validator.ts"() {
@@ -42882,6 +43319,7 @@ var init_dist = __esm({
               description: "The class or attribute to toggle",
               required: true,
               expectedTypes: ["selector"],
+              selectorKinds: ["class", "attribute"],
               svoPosition: 1,
               sovPosition: 2
             },
@@ -54117,15 +54555,6 @@ var init_dist = __esm({
     });
     init_types2 = __esm2({
       "src/types.ts"() {
-        VALID_REFERENCES = /* @__PURE__ */ new Set([
-          "me",
-          "you",
-          "it",
-          "result",
-          "event",
-          "target",
-          "body"
-        ]);
       }
     });
     init_shared = __esm2({
@@ -55288,25 +55717,10 @@ var init_dist = __esm({
           }
           /**
            * Render a semantic node in explicit mode.
+           * Delegates to @lokascript/framework/ir for the core logic.
            */
           renderExplicit(node) {
-            if (node.kind === "compound") {
-              const compoundNode = node;
-              const renderedStatements = compoundNode.statements.map((stmt) => this.renderExplicit(stmt));
-              return renderedStatements.join(` ${compoundNode.chainType} `);
-            }
-            const parts = [node.action];
-            for (const [role, value] of node.roles) {
-              parts.push(`${role}:${this.valueToString(value)}`);
-            }
-            if (node.kind === "event-handler") {
-              const eventNode = node;
-              if (eventNode.body && eventNode.body.length > 0) {
-                const bodyParts = eventNode.body.map((n) => this.renderExplicit(n));
-                parts.push(`body:${bodyParts.join(" ")}`);
-              }
-            }
-            return `[${parts.join(" ")}]`;
+            return renderExplicit$1(node);
           }
           /**
            * Get all supported languages.
@@ -55399,41 +55813,21 @@ var init_dist = __esm({
                   }
                 }
                 const groupParts = [];
+                let hasRoleValue = false;
                 for (const subToken of token.tokens) {
                   const rendered = this.renderPatternToken(subToken, node, language);
                   if (rendered !== null) {
                     groupParts.push(rendered);
+                    if (subToken.type === "role") hasRoleValue = true;
                   }
                 }
+                if (token.optional && !hasRoleValue) return null;
                 return groupParts.length > 0 ? groupParts.join(" ") : null;
               }
               default:
                 return null;
             }
           }
-          /**
-           * Convert a semantic value to a string for explicit syntax.
-           */
-          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 `${this.valueToString(value.object)}'s ${value.property}`;
-              case "expression":
-                return value.raw;
-            }
-          }
           /**
            * Convert a semantic value to natural language string.
            * Uses language-specific possessive rendering when language is provided.
@@ -55453,6 +55847,8 @@ var init_dist = __esm({
                 return this.renderPropertyPath(value, language);
               case "expression":
                 return value.raw;
+              case "flag":
+                return value.name;
             }
           }
           /**
@@ -55525,8 +55921,8 @@ var init_dist = __esm({
     });
     init_parser = __esm2({
       "src/explicit/parser.ts"() {
-        init_types2();
         init_command_schemas();
+        hyperscriptSchemaLookup = { getSchema };
       }
     });
     semantic_parser_exports = {};
@@ -59245,6 +59641,276 @@ var init_dist = __esm({
     };
     DEFAULT_EVENT_TYPE = "click";
     DEFAULT_LANGUAGE$1 = "en";
+    RingBuffer = class {
+      constructor(capacity) {
+        this.capacity = capacity;
+        this.head = 0;
+        this.count = 0;
+        this.items = new Array(capacity);
+      }
+      push(item) {
+        this.items[this.head] = item;
+        this.head = (this.head + 1) % this.capacity;
+        if (this.count < this.capacity)
+          this.count++;
+      }
+      toArray() {
+        if (this.count < this.capacity) {
+          return this.items.slice(0, this.count);
+        }
+        return [...this.items.slice(this.head), ...this.items.slice(0, this.head)];
+      }
+      get length() {
+        return this.count;
+      }
+      clear() {
+        this.head = 0;
+        this.count = 0;
+      }
+      last() {
+        if (this.count === 0)
+          return void 0;
+        const idx = (this.head - 1 + this.capacity) % this.capacity;
+        return this.items[idx];
+      }
+    };
+    HISTORY_CAPACITY = 200;
+    DebugController = class {
+      constructor() {
+        this.state = {
+          enabled: false,
+          paused: false,
+          stepMode: "continue",
+          callDepth: 0,
+          pauseDepth: 0,
+          currentSnapshot: null
+        };
+        this.history = new RingBuffer(HISTORY_CAPACITY);
+        this.breakpoints = /* @__PURE__ */ new Map();
+        this.snapshotIndex = 0;
+        this._resumeResolver = null;
+        this.listeners = /* @__PURE__ */ new Map();
+        this.hooks = {
+          beforeExecute: this.beforeExecute.bind(this),
+          afterExecute: this.afterExecute.bind(this)
+        };
+      }
+      on(event, listener) {
+        let set = this.listeners.get(event);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.listeners.set(event, set);
+        }
+        set.add(listener);
+        return () => set.delete(listener);
+      }
+      emit(event, data) {
+        const set = this.listeners.get(event);
+        if (set) {
+          for (const listener of set) {
+            try {
+              listener(data);
+            } catch {
+            }
+          }
+        }
+      }
+      enable() {
+        this.state.enabled = true;
+        this.emit("enabled");
+      }
+      disable() {
+        if (this.state.paused && this._resumeResolver) {
+          this._resumeResolver();
+          this._resumeResolver = null;
+        }
+        this.state.enabled = false;
+        this.state.paused = false;
+        this.state.stepMode = "continue";
+        this.state.callDepth = 0;
+        this.emit("disabled");
+      }
+      get enabled() {
+        return this.state.enabled;
+      }
+      continue() {
+        this.state.stepMode = "continue";
+        this.resume();
+      }
+      pause() {
+        this.state.stepMode = "pause";
+      }
+      stepOver() {
+        this.state.stepMode = "over";
+        this.state.pauseDepth = this.state.callDepth;
+        this.resume();
+      }
+      stepInto() {
+        this.state.stepMode = "into";
+        this.resume();
+      }
+      stepOut() {
+        this.state.stepMode = "out";
+        this.state.pauseDepth = this.state.callDepth;
+        this.resume();
+      }
+      resume() {
+        if (this._resumeResolver) {
+          this.state.paused = false;
+          this.emit("resumed");
+          this._resumeResolver();
+          this._resumeResolver = null;
+        }
+      }
+      setBreakpoint(condition) {
+        const id = `bp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        this.breakpoints.set(id, { ...condition, id, hitCount: 0 });
+        return id;
+      }
+      removeBreakpoint(id) {
+        return this.breakpoints.delete(id);
+      }
+      getBreakpoints() {
+        return Array.from(this.breakpoints.values());
+      }
+      clearBreakpoints() {
+        this.breakpoints.clear();
+      }
+      getState() {
+        return { ...this.state };
+      }
+      getHistory() {
+        return this.history.toArray();
+      }
+      clearHistory() {
+        this.history.clear();
+        this.snapshotIndex = 0;
+      }
+      async beforeExecute(ctx) {
+        if (!this.state.enabled)
+          return;
+        this.state.callDepth++;
+        const snapshot = this.captureSnapshot(ctx);
+        this.history.push(snapshot);
+        this.emit("snapshot", snapshot);
+        if (this.shouldPause(ctx)) {
+          this.state.paused = true;
+          this.state.currentSnapshot = snapshot;
+          this.emit("paused", snapshot);
+          await new Promise((resolve) => {
+            this._resumeResolver = resolve;
+          });
+          this.state.currentSnapshot = null;
+        }
+      }
+      async afterExecute(ctx, result) {
+        if (!this.state.enabled)
+          return;
+        const lastSnapshot = this.history.last();
+        if (lastSnapshot) {
+          lastSnapshot.variables["__result"] = serializeValue(result);
+        }
+        this.state.callDepth = Math.max(0, this.state.callDepth - 1);
+      }
+      shouldPause(ctx) {
+        if (this.hitBreakpoint(ctx))
+          return true;
+        switch (this.state.stepMode) {
+          case "pause":
+            this.state.stepMode = "into";
+            return true;
+          case "into":
+            return true;
+          case "over":
+            return this.state.callDepth <= this.state.pauseDepth;
+          case "out":
+            return this.state.callDepth < this.state.pauseDepth;
+          case "continue":
+            return false;
+        }
+      }
+      hitBreakpoint(ctx) {
+        for (const bp of this.breakpoints.values()) {
+          if (!bp.enabled)
+            continue;
+          let hit = false;
+          switch (bp.type) {
+            case "command":
+              hit = ctx.commandName === bp.value;
+              break;
+            case "element":
+              if (ctx.element) {
+                try {
+                  hit = ctx.element.matches(bp.value);
+                } catch {
+                }
+              }
+              break;
+            case "expression":
+              hit = this.evaluateCondition(bp.value, ctx);
+              break;
+          }
+          if (hit) {
+            bp.hitCount++;
+            return true;
+          }
+        }
+        return false;
+      }
+      evaluateCondition(expression, ctx) {
+        try {
+          const ec = ctx.executionContext;
+          const vars = {
+            commandName: ctx.commandName,
+            it: ec.it,
+            result: ec.result,
+            me: ec.me
+          };
+          if (ec.locals) {
+            for (const [k, v2] of ec.locals) {
+              vars[k] = v2;
+            }
+          }
+          const keys = Object.keys(vars);
+          const values = keys.map((k) => vars[k]);
+          const fn = new Function(...keys, `return (${expression});`);
+          return !!fn(...values);
+        } catch {
+          return false;
+        }
+      }
+      captureSnapshot(ctx) {
+        const ec = ctx.executionContext;
+        const variables = {};
+        variables["it"] = serializeValue(ec.it);
+        variables["result"] = serializeValue(ec.result);
+        if (ec.me)
+          variables["me"] = describeElement(ec.me);
+        if (ec.you)
+          variables["you"] = describeElement(ec.you);
+        if (ctx.event) {
+          variables["event.type"] = ctx.event.type;
+          if (ctx.event.target) {
+            variables["event.target"] = describeElement(ctx.event.target);
+          }
+        }
+        if (ec.locals) {
+          for (const [key, value] of ec.locals) {
+            if (!key.startsWith("__")) {
+              variables[`:${key}`] = serializeValue(value);
+            }
+          }
+        }
+        return {
+          commandName: ctx.commandName,
+          element: ctx.element,
+          variables,
+          timestamp: Date.now(),
+          depth: this.state.callDepth,
+          index: this.snapshotIndex++
+        };
+      }
+    };
     DEFAULT_LANGUAGE = "en";
     ASTCache = class {
       constructor(maxSize = 500) {
@@ -59306,6 +59972,7 @@ var init_dist = __esm({
       confidenceThreshold: DEFAULT_CONFIDENCE_THRESHOLD
     };
     _defaultRuntime = null;
+    _debugController = null;
     initializeDOMProcessor(compileSync, compileAsync, getDefaultRuntime);
     hyperscript = {
       compile: compileAsync,
@@ -59328,7 +59995,10 @@ var init_dist = __esm({
         return getDefaultRuntime().getRegisteredHooks();
       },
       clearCache: () => astCache.clear(),
-      getCacheStats: () => astCache.getStats()
+      getCacheStats: () => astCache.getStats(),
+      get debug() {
+        return getDebugController();
+      }
     };
     lokascript = hyperscript;
     OP_TABLE = {
@@ -65892,13 +66562,333 @@ function analyze2(ast) {
   const analyzer = new Analyzer();
   return analyzer.analyze(ast);
 }
+function extractClassOp2(node) {
+  if (node.type !== "command") return null;
+  const cmd = node;
+  if (!CLASS_COMMANDS.has(cmd.name)) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "selector") return null;
+  const selector = arg.value;
+  if (!selector.startsWith(".")) return null;
+  const className = selector.slice(1);
+  if (!className) return null;
+  return {
+    command: cmd.name,
+    className,
+    hasExplicitTarget: !!cmd.target
+  };
+}
+function isSameTarget(a, b) {
+  if (a.type !== "command" || b.type !== "command") return false;
+  const cmdA = a;
+  const cmdB = b;
+  if (!cmdA.target && !cmdB.target) return true;
+  if (cmdA.target && cmdB.target) {
+    return getTargetKey(cmdA.target) === getTargetKey(cmdB.target);
+  }
+  return false;
+}
+function getTargetKey(target) {
+  if (target.type === "selector") {
+    return `selector:${target.value}`;
+  }
+  if (target.type === "identifier") {
+    return `identifier:${target.value}`;
+  }
+  return null;
+}
+function resolveTarget2(cmd) {
+  if (!cmd.target) return "_ctx.me";
+  if (cmd.target.type === "selector") {
+    const sel = cmd.target.value;
+    if (sel.startsWith("#") && !sel.includes(" ") && !sel.includes(".")) {
+      return `document.getElementById('${sel.slice(1)}')`;
+    }
+    return `document.querySelector('${sel}')`;
+  }
+  if (cmd.target.type === "identifier") {
+    const val = cmd.target.value;
+    if (val === "me") return "_ctx.me";
+    return val;
+  }
+  return "_ctx.me";
+}
+function createBatchNode(run) {
+  const adds = [];
+  const removes = [];
+  const toggles = [];
+  for (const node of run) {
+    const op = extractClassOp2(node);
+    switch (op.command) {
+      case "add":
+        adds.push(op.className);
+        break;
+      case "remove":
+        removes.push(op.className);
+        break;
+      case "toggle":
+        toggles.push(op.className);
+        break;
+    }
+  }
+  const target = resolveTarget2(run[0]);
+  return {
+    type: "batchedClassOps",
+    target,
+    adds,
+    removes,
+    toggles
+  };
+}
+function batchBody(nodes) {
+  const result = [];
+  let currentRun = [];
+  function flushRun() {
+    if (currentRun.length >= 2) {
+      result.push(createBatchNode(currentRun));
+    } else if (currentRun.length === 1) {
+      result.push(currentRun[0]);
+    }
+    currentRun = [];
+  }
+  for (const node of nodes) {
+    const op = extractClassOp2(node);
+    if (op) {
+      if (currentRun.length > 0 && isSameTarget(currentRun[0], node)) {
+        currentRun.push(node);
+      } else {
+        flushRun();
+        currentRun = [node];
+      }
+    } else {
+      flushRun();
+      result.push(node);
+    }
+  }
+  flushRun();
+  return result;
+}
+function walkAndBatch(node) {
+  switch (node.type) {
+    case "event": {
+      const event = node;
+      if (event.body && event.body.length > 0) {
+        return { ...event, body: batchBody(event.body).map(walkAndBatch) };
+      }
+      return node;
+    }
+    case "if": {
+      const ifNode = node;
+      const result = { ...ifNode };
+      result.thenBranch = batchBody(ifNode.thenBranch).map(walkAndBatch);
+      if (ifNode.elseBranch) {
+        result.elseBranch = batchBody(ifNode.elseBranch).map(walkAndBatch);
+      }
+      if (ifNode.elseIfBranches) {
+        result.elseIfBranches = ifNode.elseIfBranches.map((branch) => ({
+          condition: branch.condition,
+          body: batchBody(branch.body).map(walkAndBatch)
+        }));
+      }
+      return result;
+    }
+    case "repeat": {
+      const repeat = node;
+      return { ...repeat, body: batchBody(repeat.body).map(walkAndBatch) };
+    }
+    case "foreach": {
+      const forEach = node;
+      return { ...forEach, body: batchBody(forEach.body).map(walkAndBatch) };
+    }
+    case "while": {
+      const whileNode = node;
+      return { ...whileNode, body: batchBody(whileNode.body).map(walkAndBatch) };
+    }
+    default:
+      return node;
+  }
+}
 function createOptimizer() {
-  return new OptimizationPipeline();
+  return /* @__PURE__ */ new OptimizationPipeline();
 }
 function optimize(ast, analysis, level = 2) {
   const pipeline = new OptimizationPipeline();
   return pipeline.optimize(ast, analysis, level);
 }
+function classifyCommand(node) {
+  if (node.type !== "command") return null;
+  const cmd = node;
+  switch (cmd.name) {
+    case "add":
+      return classifyAddCommand(cmd);
+    case "remove":
+      return classifyRemoveCommand(cmd);
+    case "put":
+      return classifyPutCommand(cmd);
+    case "set":
+      return classifySetCommand(cmd);
+    default:
+      return null;
+  }
+}
+function getIdTarget(cmd) {
+  if (!cmd.target) return null;
+  if (cmd.target.type !== "selector") return null;
+  const sel = cmd.target.value;
+  if (!sel.startsWith("#")) return null;
+  return sel.slice(1);
+}
+function classifyAddCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "selector") return null;
+  const val = arg.value;
+  if (!val.startsWith(".")) return null;
+  return { type: "addClass", targetId, value: val.slice(1) };
+}
+function classifyRemoveCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "selector") return null;
+  const val = arg.value;
+  if (!val.startsWith(".")) return null;
+  return { type: "removeClass", targetId, value: val.slice(1) };
+}
+function classifyPutCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.type !== "literal") return null;
+  const val = arg.value;
+  if (typeof val !== "string") return null;
+  return { type: "putContent", targetId, value: val };
+}
+function classifySetCommand(cmd) {
+  const targetId = getIdTarget(cmd);
+  if (!targetId) return null;
+  const args = cmd.args ?? [];
+  if (args.length < 2) return null;
+  const attrArg = args[0];
+  if (attrArg.type !== "identifier") return null;
+  const attrValue = attrArg.value;
+  if (!attrValue || !attrValue.startsWith("@")) return null;
+  const attrName = attrValue.slice(1);
+  const valArg = args[1];
+  if (valArg.type !== "literal") return null;
+  const val = valArg.value;
+  if (typeof val !== "string" && typeof val !== "number") return null;
+  return { type: "setAttribute", targetId, value: String(val), attrName };
+}
+function classifyInitCommands(commands) {
+  const pure = [];
+  const impure = [];
+  for (let i = 0; i < commands.length; i++) {
+    const classified = classifyCommand(commands[i]);
+    if (classified) {
+      pure.push({ index: i, command: classified });
+    } else {
+      impure.push({ index: i, node: commands[i] });
+    }
+  }
+  return { pure, impure };
+}
+function applyPureCommand(html, cmd) {
+  switch (cmd.type) {
+    case "addClass":
+      return addClassToElement(html, cmd.targetId, cmd.value);
+    case "removeClass":
+      return removeClassFromElement(html, cmd.targetId, cmd.value);
+    case "putContent":
+      return putContentIntoElement(html, cmd.targetId, cmd.value);
+    case "setAttribute":
+      return setAttributeOnElement(html, cmd.targetId, cmd.attrName, cmd.value);
+    default:
+      return html;
+  }
+}
+function transformElementById(html, id, transform) {
+  const idPattern = new RegExp(`(<[^>]*\\bid=["']${escapeRegExp(id)}["'][^>]*>)`, "i");
+  const match = html.match(idPattern);
+  if (!match) return html;
+  return html.replace(match[1], transform(match[1]));
+}
+function addClassToElement(html, id, className) {
+  return transformElementById(html, id, (tag) => {
+    const classMatch = tag.match(/\bclass=["']([^"']*)["']/i);
+    if (classMatch) {
+      const existing = classMatch[1];
+      const classes = existing.split(/\s+/).filter(Boolean);
+      if (!classes.includes(className)) {
+        classes.push(className);
+      }
+      return tag.replace(classMatch[0], `class="${classes.join(" ")}"`);
+    }
+    return tag.replace(/>$/, ` class="${className}">`);
+  });
+}
+function removeClassFromElement(html, id, className) {
+  return transformElementById(html, id, (tag) => {
+    const classMatch = tag.match(/\bclass=["']([^"']*)["']/i);
+    if (!classMatch) return tag;
+    const classes = classMatch[1].split(/\s+/).filter((c) => c !== className);
+    if (classes.length === 0) {
+      return tag.replace(classMatch[0], "").replace(/\s+>/, ">");
+    }
+    return tag.replace(classMatch[0], `class="${classes.join(" ")}"`);
+  });
+}
+function putContentIntoElement(html, id, content) {
+  const idPattern = new RegExp(
+    `(<[a-zA-Z][^>]*\\bid=["']${escapeRegExp(id)}["'][^>]*>)((?:(?!<\\/[a-zA-Z]).)*?)(<\\/[a-zA-Z][^>]*>)`,
+    "is"
+  );
+  const match = html.match(idPattern);
+  if (!match) return html;
+  return html.replace(match[0], `${match[1]}${escapeHtml(content)}${match[3]}`);
+}
+function setAttributeOnElement(html, id, attrName, value) {
+  return transformElementById(html, id, (tag) => {
+    const attrPattern = new RegExp(`\\b${escapeRegExp(attrName)}=["'][^"']*["']`, "i");
+    const attrMatch = tag.match(attrPattern);
+    if (attrMatch) {
+      return tag.replace(attrMatch[0], `${attrName}="${escapeHtml(value)}"`);
+    }
+    return tag.replace(/>$/, ` ${attrName}="${escapeHtml(value)}">`);
+  });
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function preRenderInitBlock(html, initCommands) {
+  const { pure, impure } = classifyInitCommands(initCommands);
+  let modifiedHtml = html;
+  let preRenderedCount = 0;
+  for (const { command: command2 } of pure) {
+    const before = modifiedHtml;
+    modifiedHtml = applyPureCommand(modifiedHtml, command2);
+    if (modifiedHtml !== before) {
+      preRenderedCount++;
+    }
+  }
+  return {
+    html: modifiedHtml,
+    remainingInitCommands: impure.map((i) => i.node),
+    preRenderedCount
+  };
+}
 function sanitizeClassName(name) {
   if (!/^-?[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
     return null;
@@ -66056,12 +67046,13 @@ async function createMultilingualCompiler() {
   }
   return compiler;
 }
-var DEFAULT_OPTIONS, ELEMENT_REGEX, SCRIPT_TAG_REGEX, ID_REGEX, CLASS_REGEX, LANG_REGEX, HTMLScanner, VueScanner, SvelteScanner, JSXScanner, Analyzer, AnalysisVisitor, ConstantFoldingPass, SelectorCachingPass, DeadCodeEliminationPass, LoopUnrollingPass, OptimizationPipeline, ExpressionCodegen, ToggleCodegen, AddCodegen, RemoveCodegen, SetCodegen, PutCodegen, ShowCodegen, HideCodegen, FocusCodegen, BlurCodegen, LogCodegen, WaitCodegen, FetchCodegen, SendCodegen, IncrementCodegen, DecrementCodegen, HaltCodegen, ExitCodegen, ReturnCodegen, CallCodegen, ScrollCodegen, TakeCodegen, UnlessCodegen, ThrowCodegen, DefaultCodegen, GoCodegen, AppendCodegen, PickCodegen, PushUrlCodegen, ReplaceUrlCodegen, GetCodegen, BreakCodegen, ContinueCodegen, BeepCodegen, JsCodegen, CopyCodegen, MakeCodegen, SwapCodegen, MorphCodegen, TransitionCodegen, MeasureCodegen, SettleCodegen, TellCodegen, AsyncCodegen, InstallCodegen, RenderCodegen, commandCodegens, EventHandlerCodegen, DEFAULT_COMPILE_OPTIONS, DEFAULT_CODEGEN_OPTIONS, AOTCompiler, VERSION2;
+var import_framework2, DEFAULT_OPTIONS, ELEMENT_REGEX, SCRIPT_TAG_REGEX, ID_REGEX, CLASS_REGEX, LANG_REGEX, HTMLScanner, VueScanner, SvelteScanner, JSXScanner, Analyzer, AnalysisVisitor, CLASS_COMMANDS, ClassBatchingPass, ConstantFoldingPass, SelectorCachingPass, DeadCodeEliminationPass, LoopUnrollingPass, OptimizationPipeline, ExpressionCodegen, ToggleCodegen, AddCodegen, RemoveCodegen, SetCodegen, PutCodegen, ShowCodegen, HideCodegen, FocusCodegen, BlurCodegen, LogCodegen, WaitCodegen, FetchCodegen, SendCodegen, IncrementCodegen, DecrementCodegen, HaltCodegen, ExitCodegen, ReturnCodegen, CallCodegen, ScrollCodegen, TakeCodegen, UnlessCodegen, ThrowCodegen, DefaultCodegen, GoCodegen, AppendCodegen, PickCodegen, PushUrlCodegen, ReplaceUrlCodegen, GetCodegen, BreakCodegen, ContinueCodegen, BeepCodegen, JsCodegen, CopyCodegen, MakeCodegen, SwapCodegen, MorphCodegen, TransitionCodegen, MeasureCodegen, SettleCodegen, TellCodegen, AsyncCodegen, InstallCodegen, RenderCodegen, commandCodegens, EventHandlerCodegen, DEFAULT_COMPILE_OPTIONS, DEFAULT_CODEGEN_OPTIONS, AOTCompiler, VERSION2;
 var init_dist2 = __esm({
   "../aot-compiler/dist/index.js"() {
     "use strict";
     init_chunk_PPZXJJ57();
     init_chunk_QKE5BEQY();
+    import_framework2 = require("@lokascript/framework");
     DEFAULT_OPTIONS = {
       attributeNames: ["_", "data-hs", "data-hyperscript"],
       includeScriptTags: true,
@@ -66679,6 +67670,18 @@ var init_dist2 = __esm({
         }
       }
     };
+    CLASS_COMMANDS = /* @__PURE__ */ new Set(["add", "remove", "toggle"]);
+    ClassBatchingPass = class {
+      constructor() {
+        this.name = "class-batching";
+      }
+      shouldRun(analysis) {
+        return analysis.commandsUsed.has("add") || analysis.commandsUsed.has("remove") || analysis.commandsUsed.has("toggle");
+      }
+      transform(ast, _analysis) {
+        return walkAndBatch(ast);
+      }
+    };
     ConstantFoldingPass = class {
       constructor() {
         this.name = "constant-folding";
@@ -67003,6 +68006,7 @@ var init_dist2 = __esm({
           new ConstantFoldingPass(),
           new SelectorCachingPass(),
           new DeadCodeEliminationPass(),
+          new ClassBatchingPass(),
           new LoopUnrollingPass()
         ];
       }
@@ -68798,6 +69802,22 @@ var init_dist2 = __esm({
             const nested = node;
             return this.generateBody(nested.body ?? []);
           }
+          case "batchedClassOps": {
+            const batch = node;
+            const lines = [];
+            if (batch.adds.length > 0) {
+              lines.push(`${batch.target}.classList.add(${batch.adds.map((c) => `'${c}'`).join(", ")})`);
+            }
+            if (batch.removes.length > 0) {
+              lines.push(
+                `${batch.target}.classList.remove(${batch.removes.map((c) => `'${c}'`).join(", ")})`
+              );
+            }
+            for (const t of batch.toggles) {
+              lines.push(`${batch.target}.classList.toggle('${t}')`);
+            }
+            return lines.join(";\n");
+          }
           default:
             return null;
         }
@@ -69022,10 +70042,40 @@ var init_dist2 = __esm({
       // ===========================================================================
       /**
        * Parse a hyperscript string to AST.
+       * Supports natural language, explicit bracket syntax, and JSON input.
        */
       parse(code, options = {}) {
         const { language = "en", confidenceThreshold = 0.7, debug: debug2 = false } = options;
         let ast = null;
+        if ((0, import_framework2.isExplicitSyntax)(code)) {
+          try {
+            const node = (0, import_framework2.parseExplicit)(code);
+            ast = this.semanticNodeToAOT(node);
+            if (debug2) {
+              console.log(`[aot] Parsed explicit syntax: "${code}"`);
+            }
+          } catch (error) {
+            if (debug2) {
+              console.log(`[aot] Explicit parse error for "${code}":`, error);
+            }
+          }
+          if (ast) return this.ensureEventHandler(ast);
+        }
+        if (this.looksLikeJSON(code)) {
+          try {
+            const json = JSON.parse(code.trim());
+            const node = (0, import_framework2.fromProtocolJSON)(json);
+            ast = this.semanticNodeToAOT(node);
+            if (debug2) {
+              console.log(`[aot] Parsed JSON input: "${code.slice(0, 80)}..."`);
+            }
+          } catch (error) {
+            if (debug2) {
+              console.log(`[aot] JSON parse error for "${code.slice(0, 80)}":`, error);
+            }
+          }
+          if (ast) return this.ensureEventHandler(ast);
+        }
         if (language !== "en" && this.semanticParser?.supportsLanguage(language)) {
           const result = this.semanticParser.analyze(code, language);
           if (result.node && result.confidence >= confidenceThreshold) {
@@ -69052,15 +70102,7 @@ var init_dist2 = __esm({
         if (!ast) {
           ast = this.createSimpleAST(code);
         }
-        if (ast && ast.type !== "event") {
-          ast = {
-            type: "event",
-            event: "click",
-            modifiers: {},
-            body: [ast]
-          };
-        }
-        return ast;
+        return this.ensureEventHandler(ast);
       }
       /**
        * Create a simple AST from code (for testing without full parser).
@@ -69225,6 +70267,86 @@ var init_dist2 = __esm({
         return { type: "identifier", value: trimmed };
       }
       // ===========================================================================
+      // EXPLICIT / JSON INPUT HELPERS
+      // ===========================================================================
+      /**
+       * Check if input looks like JSON (LLM JSON format).
+       */
+      looksLikeJSON(code) {
+        const trimmed = code.trim();
+        return trimmed.startsWith("{") && trimmed.includes('"action"');
+      }
+      /**
+       * Ensure top-level node is always an event handler.
+       * The codegen pipeline (EventHandlerCodegen) requires this.
+       */
+      ensureEventHandler(ast) {
+        if (ast && ast.type !== "event") {
+          return {
+            type: "event",
+            event: "click",
+            modifiers: {},
+            body: [ast]
+          };
+        }
+        return ast;
+      }
+      /**
+       * Convert a framework SemanticNode to an AOT ASTNode.
+       * Handles the simple cases produced by explicit/JSON parsing.
+       */
+      semanticNodeToAOT(node) {
+        if (node.kind === "event-handler") {
+          const eh = node;
+          const eventValue = eh.roles.get("event");
+          const eventName = eventValue && "value" in eventValue ? String(eventValue.value) : "click";
+          return {
+            type: "event",
+            event: eventName,
+            modifiers: {},
+            body: (eh.body ?? []).map((child) => this.semanticNodeToAOT(child))
+          };
+        }
+        const roles = {};
+        const args = [];
+        for (const [roleName, value] of node.roles) {
+          const astValue = this.semanticValueToAOT(value);
+          roles[roleName] = astValue;
+          args.push(astValue);
+        }
+        return {
+          type: "command",
+          name: node.action,
+          args,
+          roles
+        };
+      }
+      /**
+       * Convert a SemanticValue to an ASTNode.
+       */
+      semanticValueToAOT(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 };
+          }
+          default:
+            return { type: "literal", value: String(value.value ?? "") };
+        }
+      }
+      // ===========================================================================
       // ANALYSIS
       // ===========================================================================
       /**
@@ -69234,6 +70356,63 @@ var init_dist2 = __esm({
         return this.analyzer.analyze(ast);
       }
       // ===========================================================================
+      // INIT PRE-RENDERING
+      // ===========================================================================
+      /**
+       * Pre-render pure init block commands into an HTML template at build time.
+       *
+       * Analyzes init block commands for purity (static DOM writes with literal
+       * values targeting #id selectors) and applies them directly to the HTML.
+       * Impure commands are preserved for normal runtime execution.
+       *
+       * @param html - The HTML template string
+       * @param initCommands - Parsed commands from an init block
+       * @returns Modified HTML, remaining impure commands, and count of pre-rendered commands
+       */
+      preRenderInit(html, initCommands) {
+        return preRenderInitBlock(html, initCommands);
+      }
+      /**
+       * Extract init blocks from HTML, pre-render pure commands, and return modified HTML.
+       * This is a higher-level convenience that combines extraction, parsing, and pre-rendering.
+       *
+       * @param html - The HTML template string
+       * @param options - Compile options (language, etc.)
+       * @returns Modified HTML with pre-rendered init effects and compilation results
+       */
+      preRenderInitBlocks(html, options = {}) {
+        const scripts = this.extract(html, "template.html");
+        let modifiedHtml = html;
+        let totalPreRendered = 0;
+        const remainingScripts = [];
+        for (const script of scripts) {
+          const ast = this.parse(script.code, {
+            ...options,
+            language: script.language ?? options.language ?? "en"
+          });
+          if (!ast) {
+            remainingScripts.push(script);
+            continue;
+          }
+          const eventNode = ast;
+          if (eventNode.type === "event" && eventNode.event === "init" && eventNode.body) {
+            const result = preRenderInitBlock(modifiedHtml, eventNode.body);
+            modifiedHtml = result.html;
+            totalPreRendered += result.preRenderedCount;
+            if (result.remainingInitCommands.length > 0) {
+              remainingScripts.push(script);
+            }
+          } else {
+            remainingScripts.push(script);
+          }
+        }
+        return {
+          html: modifiedHtml,
+          preRenderedCount: totalPreRendered,
+          remainingScripts
+        };
+      }
+      // ===========================================================================
       // COMPILATION
       // ===========================================================================
       /**
@@ -69356,6 +70535,30 @@ var init_dist2 = __esm({
           }
         };
       }
+      /**
+       * Compile explicit bracket syntax or LLM JSON to JavaScript.
+       * Uses the framework IR directly — no semantic or traditional parser needed.
+       */
+      compileExplicit(code, options = {}) {
+        try {
+          const ast = (0, import_framework2.isExplicitSyntax)(code) ? this.semanticNodeToAOT((0, import_framework2.parseExplicit)(code)) : this.semanticNodeToAOT((0, import_framework2.fromProtocolJSON)(JSON.parse(code.trim())));
+          return this.compileAST(ast, options);
+        } catch (error) {
+          return {
+            success: false,
+            errors: [error instanceof Error ? error.message : String(error)],
+            warnings: [],
+            metadata: {
+              handlerId: "",
+              parserUsed: "traditional",
+              commandsUsed: [],
+              optimizationsApplied: [],
+              needsRuntime: false,
+              runtimeHelpers: []
+            }
+          };
+        }
+      }
       /**
        * Compile multiple extracted scripts.
        */
@@ -69595,8 +70798,8 @@ __export(index_exports, {
   diffBehaviors: () => diffBehaviors,
   extractOperations: () => extractOperations,
   generateCacheKey: () => generateCacheKey,
-  jsonToSemanticNode: () => jsonToSemanticNode,
-  validateSemanticJSON: () => validateSemanticJSON
+  jsonToSemanticNode: () => import_ir.jsonToSemanticNode,
+  validateSemanticJSON: () => import_ir.validateSemanticJSON
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -69870,119 +71073,8 @@ function detectFormat(input) {
   return "natural";
 }
 
-// src/input/json-schema.ts
-var VALID_VALUE_TYPES = /* @__PURE__ */ new Set(["selector", "literal", "reference", "expression"]);
-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 v2 = value;
-      if (!VALID_VALUE_TYPES.has(v2.type)) {
-        diagnostics.push({
-          severity: "error",
-          code: "INVALID_VALUE_TYPE",
-          message: `Role "${role}" has invalid type "${v2.type}".`,
-          suggestion: `Valid types: selector, literal, reference, expression.`
-        });
-      }
-      if (v2.value === void 0 || v2.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", { type: "literal", value: input.trigger.event, dataType: "string" });
-    const bodyNode = {
-      kind: "command",
-      action: input.action,
-      roles: new Map(roles)
-    };
-    bodyNode.roles.delete("event");
-    return {
-      kind: "event-handler",
-      action: "on",
-      roles,
-      body: [bodyNode],
-      eventModifiers: input.trigger.modifiers ?? {}
-    };
-  }
-  return {
-    kind: "command",
-    action: input.action,
-    roles
-  };
-}
-function convertJSONValue(value) {
-  switch (value.type) {
-    case "selector":
-      return {
-        type: "selector",
-        value: String(value.value),
-        selectorKind: detectSelectorKind(String(value.value))
-      };
-    case "literal":
-      return {
-        type: "literal",
-        value: value.value,
-        dataType: typeof value.value === "number" ? "number" : typeof value.value === "boolean" ? "boolean" : "string"
-      };
-    case "reference":
-      return { type: "reference", value: String(value.value) };
-    case "expression":
-      return { type: "expression", raw: String(value.value) };
-    default:
-      return { type: "literal", value: String(value.value), dataType: "string" };
-  }
-}
-function detectSelectorKind(selector) {
-  if (selector.startsWith("#")) return "id";
-  if (selector.startsWith(".")) return "class";
-  if (selector.startsWith("[")) return "attribute";
-  return "complex";
-}
-
 // src/input/normalize.ts
+var import_framework = require("@lokascript/framework");
 var _semantic = null;
 function initNormalizer(semantic) {
   _semantic = semantic;
@@ -70077,7 +71169,7 @@ function normalizeExplicit(input) {
   }
 }
 function normalizeJSON(input) {
-  const validationErrors = validateSemanticJSON(input);
+  const validationErrors = (0, import_framework.validateProtocolJSON)(input);
   if (validationErrors.some((d) => d.severity === "error")) {
     return {
       node: null,
@@ -70086,7 +71178,7 @@ function normalizeJSON(input) {
       diagnostics: validationErrors
     };
   }
-  const node = jsonToSemanticNode(input);
+  const node = (0, import_framework.fromProtocolJSON)(input);
   return {
     node,
     confidence: 1,
@@ -72905,6 +73997,9 @@ function nodeToSemanticJSON(node) {
   }
   return { action: n.action, roles };
 }
+
+// src/input/json-schema.ts
+var import_ir = require("@lokascript/framework/ir");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompilationService,