@lokascript/compilation-service 2.0.0 → 2.1.0

package/dist/{dist-JOIDNRL3.js → dist-KBC4YRQJ.js}

@@ -5119,31 +5119,7 @@ var Parser = class _Parser {
             }
           }
         }
-        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,
@@ -5156,7 +5132,6 @@ var Parser = class _Parser {
           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 = {
@@ -6946,8 +6921,9 @@ var SPECIAL_DOM_PROPERTIES = {
   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),
@@ -13846,14 +13822,31 @@ var RuntimeBase = class _RuntimeBase {
   }
   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,
@@ -16584,6 +16577,7 @@ var Operation = {
 };
 var candidateNodes = /* @__PURE__ */ new Set();
 var candidateElements = /* @__PURE__ */ new Set();
+var candidateElementsWithIds = /* @__PURE__ */ new Set();
 var unmatchedNodes = /* @__PURE__ */ new Set();
 var unmatchedElements = /* @__PURE__ */ new Set();
 var whitespaceNodes = /* @__PURE__ */ new Set();
@@ -16675,6 +16669,7 @@ var Morph = class {
     const toChildNodes = [...to.childNodes];
     candidateNodes.clear();
     candidateElements.clear();
+    candidateElementsWithIds.clear();
     unmatchedNodes.clear();
     unmatchedElements.clear();
     whitespaceNodes.clear();
@@ -16690,7 +16685,11 @@ var Morph = class {
       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 {
@@ -16733,13 +16732,13 @@ var Morph = class {
       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;
             }
@@ -16751,7 +16750,7 @@ var Morph = class {
                   if (candidateIdSet.has(arrayId)) {
                     matches[unmatchedIndex] = candidateIndex;
                     op[unmatchedIndex] = Operation.SameElement;
-                    candidateElements.delete(candidateIndex);
+                    candidateElementsWithIds.delete(candidateIndex);
                     unmatchedElements.delete(unmatchedIndex);
                     break candidateLoop;
                   }
@@ -16826,6 +16825,8 @@ var Morph = class {
       __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++) {
@@ -22545,6 +22546,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 }
+  };
+}
 var DebugLogger = class {
   constructor(namespace) {
     this.namespace = namespace;
@@ -22742,7 +22802,7 @@ var _PatternMatcher$1 = class _PatternMatcher {
    * a token and the immediately following pattern token fails, the matcher
    * resets to before the optional role and retries the failed token.
    */
-  matchTokenSequence(tokens, patternTokens, captured) {
+  matchTokenSequence(tokens, patternTokens, captured, parentStopMarkers) {
     const firstPatternToken = patternTokens[0];
     const patternExpectsConjunction = firstPatternToken?.type === "literal" && (firstPatternToken.value === "and" || firstPatternToken.value === "then" || firstPatternToken.alternatives?.includes("and") || firstPatternToken.alternatives?.includes("then"));
     if (this.currentProfile?.code === "ar" && !patternExpectsConjunction) {
@@ -22766,6 +22826,9 @@ var _PatternMatcher$1 = class _PatternMatcher {
       );
       if (patternToken.type === "role" && patternToken.greedy) {
         const stopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+        if (parentStopMarkers) {
+          for (const m of parentStopMarkers) stopMarkers.add(m);
+        }
         const values = [];
         while (!tokens.isAtEnd()) {
           const nextToken = tokens.peek();
@@ -22785,8 +22848,58 @@ var _PatternMatcher$1 = class _PatternMatcher {
           return false;
         }
       }
+      if (patternToken.type === "group") {
+        const siblingStopMarkers = this.collectStopMarkers(patternTokens, i + 1);
+        if (parentStopMarkers) {
+          for (const m of parentStopMarkers) siblingStopMarkers.add(m);
+        }
+        const groupMatched = this.matchGroupToken(
+          tokens,
+          patternToken,
+          captured,
+          siblingStopMarkers
+        );
+        if (groupMatched) {
+          prevOptionalMark = null;
+          prevOptionalRole = null;
+          continue;
+        }
+        if (this.isOptional(patternToken)) {
+          continue;
+        }
+        return false;
+      }
       const isOptionalRole = patternToken.type === "role" && patternToken.optional === true;
       const markBefore = isOptionalRole ? tokens.mark() : null;
+      const isRoleToken = patternToken.type === "role";
+      if (isRoleToken && !isOptionalRole) {
+        const nextPT = i + 1 < patternTokens.length ? patternTokens[i + 1] : null;
+        if (nextPT?.type === "literal") {
+          const currentToken = tokens.peek();
+          if (currentToken && this.getMatchType(currentToken, nextPT.value) !== "none") {
+            this.logger.debug(
+              "  >> MARKER-STEAL GUARD: current token matches next literal, skipping role"
+            );
+            this.logger.debug("  >> Token match FAILED");
+            if (this.isOptional(patternToken)) {
+              continue;
+            }
+            if (prevOptionalMark && prevOptionalRole) {
+              this.logger.debug("  >> BACKTRACKING: undoing optional role", prevOptionalRole);
+              tokens.reset(prevOptionalMark);
+              captured.delete(prevOptionalRole);
+              prevOptionalMark = null;
+              prevOptionalRole = null;
+              const retryMatched = this.matchPatternToken(tokens, patternToken, captured);
+              this.logger.debug("  >> Backtrack retry result:", retryMatched);
+              if (retryMatched) {
+                continue;
+              }
+            }
+            return false;
+          }
+        }
+      }
       const matched = this.matchPatternToken(tokens, patternToken, captured);
       this.logger.debug("  >> Match result:", matched);
       if (matched) {
@@ -22907,7 +23020,7 @@ var _PatternMatcher$1 = class _PatternMatcher {
     const possessiveValue = this.tryMatchPossessiveExpression(tokens);
     if (possessiveValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(possessiveValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible$1(possessiveValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -22917,7 +23030,7 @@ var _PatternMatcher$1 = class _PatternMatcher {
     const methodCallValue = this.tryMatchMethodCallExpression(tokens);
     if (methodCallValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(methodCallValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible$1(methodCallValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -22937,7 +23050,7 @@ var _PatternMatcher$1 = class _PatternMatcher {
     const propertyAccessValue = this.tryMatchPropertyAccessExpression(tokens);
     if (propertyAccessValue) {
       if (patternToken.expectedTypes && patternToken.expectedTypes.length > 0) {
-        if (!patternToken.expectedTypes.includes(propertyAccessValue.type) && !patternToken.expectedTypes.includes("expression")) {
+        if (!isTypeCompatible$1(propertyAccessValue.type, patternToken.expectedTypes)) {
           return patternToken.optional || false;
         }
       }
@@ -23256,10 +23369,15 @@ var _PatternMatcher$1 = class _PatternMatcher {
    * (e.g., a value like 'hello') to sit between groups without blocking later
    * marker matches.
    */
-  matchGroupToken(tokens, patternToken, captured) {
+  matchGroupToken(tokens, patternToken, captured, parentStopMarkers) {
     const mark = tokens.mark();
     const capturedBefore = new Set(captured.keys());
-    const 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()) {
@@ -23281,7 +23399,12 @@ var _PatternMatcher$1 = class _PatternMatcher {
             "- skipping intervening tokens"
           );
           for (let s = 0; s < offset; s++) tokens.advance();
-          const retrySuccess = this.matchTokenSequence(tokens, patternToken.tokens, captured);
+          const retrySuccess = this.matchTokenSequence(
+            tokens,
+            patternToken.tokens,
+            captured,
+            parentStopMarkers
+          );
           if (retrySuccess) return true;
           tokens.reset(mark);
           for (const role of captured.keys()) {
@@ -23348,7 +23471,7 @@ var _PatternMatcher$1 = class _PatternMatcher {
             break;
           }
         }
-        break;
+        if (!pt.optional) break;
       }
     }
     return markers;
@@ -23358,8 +23481,9 @@ var _PatternMatcher$1 = class _PatternMatcher {
    */
   isStopMarker(token, stopMarkers) {
     if (stopMarkers.size === 0) return false;
-    const value = (token.normalized || token.value).toLowerCase();
-    return stopMarkers.has(value);
+    if (stopMarkers.has(token.value.toLowerCase())) return true;
+    if (token.normalized && stopMarkers.has(token.normalized.toLowerCase())) return true;
+    return false;
   }
   /**
    * Convert a language token to a semantic value.
@@ -23844,6 +23968,362 @@ function createTokenizerContext(tokenizer) {
   }
   return ctx;
 }
+var DEFAULT_REFERENCES = /* @__PURE__ */ new Set([
+  "me",
+  "you",
+  "it",
+  "result",
+  "event",
+  "target",
+  "body"
+]);
+function isValidReference2(value, referenceSet = DEFAULT_REFERENCES) {
+  return referenceSet.has(value);
+}
+var STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+  "body",
+  "then",
+  "else",
+  "condition",
+  "loop-body",
+  "variable",
+  "catch",
+  // v1.2: try/catch/finally
+  "finally"
+  // v1.2: try/catch/finally
+]);
+function isNestedCommand(value) {
+  const inner = value.slice(1, -1);
+  let depth = 0;
+  for (const ch of inner) {
+    if (ch === "[") depth++;
+    else if (ch === "]") depth--;
+    else if (depth === 0 && (ch === " " || ch === ":")) return true;
+  }
+  return false;
+}
+function parseExplicit$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;
+  }
+}
 var TokenStreamImpl = class {
   constructor(tokens, language) {
     this.pos = 0;
@@ -30183,6 +30663,10 @@ var init_schema_error_codes = __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"
     };
@@ -30206,6 +30690,10 @@ var init_schema_error_codes = __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."
     };
@@ -30220,6 +30708,9 @@ var init_schema_error_codes = __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."
     };
   }
@@ -30232,7 +30723,8 @@ __export(schema_validator_exports, {
   validateAllKeywordCollisions: () => validateAllKeywordCollisions,
   validateAllSchemas: () => validateAllSchemas,
   validateCommandSchema: () => validateCommandSchema,
-  validateKeywordCollisions: () => validateKeywordCollisions
+  validateKeywordCollisions: () => validateKeywordCollisions,
+  validateRoleValues: () => validateRoleValues
 });
 function createValidationResult(action, items) {
   return {
@@ -30284,6 +30776,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);
@@ -30448,6 +30954,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) {
@@ -30624,6 +31158,7 @@ var init_command_schemas = __esm({
           description: "The class or attribute to toggle",
           required: true,
           expectedTypes: ["selector"],
+          selectorKinds: ["class", "attribute"],
           svoPosition: 1,
           sovPosition: 2
         },
@@ -43633,7 +44168,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 };
@@ -43725,18 +44260,8 @@ function createLoopNode(action, loopVariant, roles, body, options) {
   }
   return node;
 }
-var VALID_REFERENCES;
 var init_types2 = __esm({
   "src/types.ts"() {
-    VALID_REFERENCES = /* @__PURE__ */ new Set([
-      "me",
-      "you",
-      "it",
-      "result",
-      "event",
-      "target",
-      "body"
-    ]);
   }
 });
 function normalizeEventName(event, language) {
@@ -44957,25 +45482,10 @@ var init_renderer = __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.
@@ -45068,41 +45578,21 @@ var init_renderer = __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.
@@ -45122,6 +45612,8 @@ var init_renderer = __esm({
             return this.renderPropertyPath(value, language);
           case "expression":
             return value.raw;
+          case "flag":
+            return value.name;
         }
       }
       /**
@@ -45193,167 +45685,15 @@ var init_renderer = __esm({
   }
 });
 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("]");
-}
+var hyperscriptSchemaLookup;
 var init_parser = __esm({
   "src/explicit/parser.ts"() {
-    init_types2();
     init_command_schemas();
+    hyperscriptSchemaLookup = { getSchema };
   }
 });
 var semantic_parser_exports = {};
@@ -54430,6 +54770,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;
   }
@@ -56144,6 +56486,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}`);
@@ -58440,6 +58784,316 @@ function process$1(element) {
     console.error("Error processing hyperscript node:", error);
   }
 }
+var 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];
+  }
+};
+var HISTORY_CAPACITY = 200;
+var 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++
+    };
+  }
+};
+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;
+}
 var DEFAULT_LANGUAGE = "en";
 var ASTCache = class {
   constructor(maxSize = 500) {
@@ -58527,6 +59181,14 @@ function getDefaultParserOptions() {
   };
 }
 var _defaultRuntime = null;
+var _debugController = null;
+function getDebugController() {
+  if (!_debugController) {
+    _debugController = new DebugController();
+    getDefaultRuntime().registerHooks("__debugger", _debugController.hooks);
+  }
+  return _debugController;
+}
 function getDefaultRuntime() {
   if (!_defaultRuntime) {
     _defaultRuntime = new Runtime({
@@ -58737,7 +59399,10 @@ var hyperscript = {
     return getDefaultRuntime().getRegisteredHooks();
   },
   clearCache: () => astCache.clear(),
-  getCacheStats: () => astCache.getStats()
+  getCacheStats: () => astCache.getStats(),
+  get debug() {
+    return getDebugController();
+  }
 };
 var lokascript = hyperscript;
 var OP_TABLE = {
@@ -65770,6 +66435,9 @@ var CompletionItemKind;
   CompletionItemKind2[CompletionItemKind2["Operator"] = 24] = "Operator";
   CompletionItemKind2[CompletionItemKind2["TypeParameter"] = 25] = "TypeParameter";
 })(CompletionItemKind || (CompletionItemKind = {}));
+function createDebugController() {
+  return new DebugController();
+}
 var _semanticModule = null;
 async function getSemanticModule() {
   if (!_semanticModule) {
@@ -65922,6 +66590,7 @@ var bridge = /* @__PURE__ */ Object.freeze({
   SemanticGrammarBridge
 });
 export {
+  DebugController,
   Lexer,
   Runtime,
   RuntimeBase,
@@ -65937,6 +66606,7 @@ export {
   createBehaviorsFeature,
   createChildContext,
   createContext,
+  createDebugController,
   createDef,
   createDefFeature,
   createEventSource,
@@ -65966,4 +66636,4 @@ export {
   toCoreAST,
   validatePartialContent
 };
-//# sourceMappingURL=dist-JOIDNRL3.js.map
+//# sourceMappingURL=dist-KBC4YRQJ.js.map