@nice-code/action 0.2.14 → 0.2.16

package/build/devtools/browser/index.js

@@ -1,21 +1,1830 @@
-// src/ActionDefinition/Action/RunningAction.types.ts
-var ERunningActionState;
-((ERunningActionState2) => {
-  ERunningActionState2["running"] = "running";
-  ERunningActionState2["completed"] = "completed";
-})(ERunningActionState ||= {});
-var ERunningActionUpdateType;
-((ERunningActionUpdateType2) => {
-  ERunningActionUpdateType2["started"] = "started";
-  ERunningActionUpdateType2["progress"] = "progress";
-  ERunningActionUpdateType2["finished"] = "finished";
-})(ERunningActionUpdateType ||= {});
-var ERunningActionFinishedType;
-((ERunningActionFinishedType2) => {
-  ERunningActionFinishedType2["aborted"] = "aborted";
-  ERunningActionFinishedType2["failed"] = "failed";
-  ERunningActionFinishedType2["success"] = "success";
-})(ERunningActionFinishedType ||= {});
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/base64.js
+var require_base64 = __commonJS((exports) => {
+  var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+  exports.encode = function(number) {
+    if (0 <= number && number < intToCharMap.length) {
+      return intToCharMap[number];
+    }
+    throw new TypeError("Must be between 0 and 63: " + number);
+  };
+  exports.decode = function(charCode) {
+    var bigA = 65;
+    var bigZ = 90;
+    var littleA = 97;
+    var littleZ = 122;
+    var zero = 48;
+    var nine = 57;
+    var plus = 43;
+    var slash = 47;
+    var littleOffset = 26;
+    var numberOffset = 52;
+    if (bigA <= charCode && charCode <= bigZ) {
+      return charCode - bigA;
+    }
+    if (littleA <= charCode && charCode <= littleZ) {
+      return charCode - littleA + littleOffset;
+    }
+    if (zero <= charCode && charCode <= nine) {
+      return charCode - zero + numberOffset;
+    }
+    if (charCode == plus) {
+      return 62;
+    }
+    if (charCode == slash) {
+      return 63;
+    }
+    return -1;
+  };
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/base64-vlq.js
+var require_base64_vlq = __commonJS((exports) => {
+  var base64 = require_base64();
+  var VLQ_BASE_SHIFT = 5;
+  var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+  var VLQ_BASE_MASK = VLQ_BASE - 1;
+  var VLQ_CONTINUATION_BIT = VLQ_BASE;
+  function toVLQSigned(aValue) {
+    return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
+  }
+  function fromVLQSigned(aValue) {
+    var isNegative = (aValue & 1) === 1;
+    var shifted = aValue >> 1;
+    return isNegative ? -shifted : shifted;
+  }
+  exports.encode = function base64VLQ_encode(aValue) {
+    var encoded = "";
+    var digit;
+    var vlq = toVLQSigned(aValue);
+    do {
+      digit = vlq & VLQ_BASE_MASK;
+      vlq >>>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base64.encode(digit);
+    } while (vlq > 0);
+    return encoded;
+  };
+  exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+    var strLen = aStr.length;
+    var result = 0;
+    var shift = 0;
+    var continuation, digit;
+    do {
+      if (aIndex >= strLen) {
+        throw new Error("Expected more digits in base 64 VLQ value.");
+      }
+      digit = base64.decode(aStr.charCodeAt(aIndex++));
+      if (digit === -1) {
+        throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+      }
+      continuation = !!(digit & VLQ_CONTINUATION_BIT);
+      digit &= VLQ_BASE_MASK;
+      result = result + (digit << shift);
+      shift += VLQ_BASE_SHIFT;
+    } while (continuation);
+    aOutParam.value = fromVLQSigned(result);
+    aOutParam.rest = aIndex;
+  };
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/util.js
+var require_util = __commonJS((exports) => {
+  function getArg(aArgs, aName, aDefaultValue) {
+    if (aName in aArgs) {
+      return aArgs[aName];
+    } else if (arguments.length === 3) {
+      return aDefaultValue;
+    } else {
+      throw new Error('"' + aName + '" is a required argument.');
+    }
+  }
+  exports.getArg = getArg;
+  var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+  var dataUrlRegexp = /^data:.+\,.+$/;
+  function urlParse(aUrl) {
+    var match = aUrl.match(urlRegexp);
+    if (!match) {
+      return null;
+    }
+    return {
+      scheme: match[1],
+      auth: match[2],
+      host: match[3],
+      port: match[4],
+      path: match[5]
+    };
+  }
+  exports.urlParse = urlParse;
+  function urlGenerate(aParsedUrl) {
+    var url = "";
+    if (aParsedUrl.scheme) {
+      url += aParsedUrl.scheme + ":";
+    }
+    url += "//";
+    if (aParsedUrl.auth) {
+      url += aParsedUrl.auth + "@";
+    }
+    if (aParsedUrl.host) {
+      url += aParsedUrl.host;
+    }
+    if (aParsedUrl.port) {
+      url += ":" + aParsedUrl.port;
+    }
+    if (aParsedUrl.path) {
+      url += aParsedUrl.path;
+    }
+    return url;
+  }
+  exports.urlGenerate = urlGenerate;
+  var MAX_CACHED_INPUTS = 32;
+  function lruMemoize(f) {
+    var cache = [];
+    return function(input) {
+      for (var i = 0;i < cache.length; i++) {
+        if (cache[i].input === input) {
+          var temp = cache[0];
+          cache[0] = cache[i];
+          cache[i] = temp;
+          return cache[0].result;
+        }
+      }
+      var result = f(input);
+      cache.unshift({
+        input,
+        result
+      });
+      if (cache.length > MAX_CACHED_INPUTS) {
+        cache.pop();
+      }
+      return result;
+    };
+  }
+  var normalize = lruMemoize(function normalize2(aPath) {
+    var path = aPath;
+    var url = urlParse(aPath);
+    if (url) {
+      if (!url.path) {
+        return aPath;
+      }
+      path = url.path;
+    }
+    var isAbsolute = exports.isAbsolute(path);
+    var parts = [];
+    var start = 0;
+    var i = 0;
+    while (true) {
+      start = i;
+      i = path.indexOf("/", start);
+      if (i === -1) {
+        parts.push(path.slice(start));
+        break;
+      } else {
+        parts.push(path.slice(start, i));
+        while (i < path.length && path[i] === "/") {
+          i++;
+        }
+      }
+    }
+    for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
+      part = parts[i];
+      if (part === ".") {
+        parts.splice(i, 1);
+      } else if (part === "..") {
+        up++;
+      } else if (up > 0) {
+        if (part === "") {
+          parts.splice(i + 1, up);
+          up = 0;
+        } else {
+          parts.splice(i, 2);
+          up--;
+        }
+      }
+    }
+    path = parts.join("/");
+    if (path === "") {
+      path = isAbsolute ? "/" : ".";
+    }
+    if (url) {
+      url.path = path;
+      return urlGenerate(url);
+    }
+    return path;
+  });
+  exports.normalize = normalize;
+  function join(aRoot, aPath) {
+    if (aRoot === "") {
+      aRoot = ".";
+    }
+    if (aPath === "") {
+      aPath = ".";
+    }
+    var aPathUrl = urlParse(aPath);
+    var aRootUrl = urlParse(aRoot);
+    if (aRootUrl) {
+      aRoot = aRootUrl.path || "/";
+    }
+    if (aPathUrl && !aPathUrl.scheme) {
+      if (aRootUrl) {
+        aPathUrl.scheme = aRootUrl.scheme;
+      }
+      return urlGenerate(aPathUrl);
+    }
+    if (aPathUrl || aPath.match(dataUrlRegexp)) {
+      return aPath;
+    }
+    if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+      aRootUrl.host = aPath;
+      return urlGenerate(aRootUrl);
+    }
+    var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
+    if (aRootUrl) {
+      aRootUrl.path = joined;
+      return urlGenerate(aRootUrl);
+    }
+    return joined;
+  }
+  exports.join = join;
+  exports.isAbsolute = function(aPath) {
+    return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
+  };
+  function relative(aRoot, aPath) {
+    if (aRoot === "") {
+      aRoot = ".";
+    }
+    aRoot = aRoot.replace(/\/$/, "");
+    var level = 0;
+    while (aPath.indexOf(aRoot + "/") !== 0) {
+      var index = aRoot.lastIndexOf("/");
+      if (index < 0) {
+        return aPath;
+      }
+      aRoot = aRoot.slice(0, index);
+      if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+        return aPath;
+      }
+      ++level;
+    }
+    return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+  }
+  exports.relative = relative;
+  var supportsNullProto = function() {
+    var obj = Object.create(null);
+    return !("__proto__" in obj);
+  }();
+  function identity(s) {
+    return s;
+  }
+  function toSetString(aStr) {
+    if (isProtoString(aStr)) {
+      return "$" + aStr;
+    }
+    return aStr;
+  }
+  exports.toSetString = supportsNullProto ? identity : toSetString;
+  function fromSetString(aStr) {
+    if (isProtoString(aStr)) {
+      return aStr.slice(1);
+    }
+    return aStr;
+  }
+  exports.fromSetString = supportsNullProto ? identity : fromSetString;
+  function isProtoString(s) {
+    if (!s) {
+      return false;
+    }
+    var length = s.length;
+    if (length < 9) {
+      return false;
+    }
+    if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
+      return false;
+    }
+    for (var i = length - 10;i >= 0; i--) {
+      if (s.charCodeAt(i) !== 36) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+    var cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0 || onlyCompareOriginal) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByOriginalPositions = compareByOriginalPositions;
+  function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
+    var cmp;
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0 || onlyCompareOriginal) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
+  function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+    var cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0 || onlyCompareGenerated) {
+      return cmp;
+    }
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+  function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
+    var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0 || onlyCompareGenerated) {
+      return cmp;
+    }
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
+  function strcmp(aStr1, aStr2) {
+    if (aStr1 === aStr2) {
+      return 0;
+    }
+    if (aStr1 === null) {
+      return 1;
+    }
+    if (aStr2 === null) {
+      return -1;
+    }
+    if (aStr1 > aStr2) {
+      return 1;
+    }
+    return -1;
+  }
+  function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+    var cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+  function parseSourceMapInput(str) {
+    return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+  }
+  exports.parseSourceMapInput = parseSourceMapInput;
+  function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+    sourceURL = sourceURL || "";
+    if (sourceRoot) {
+      if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
+        sourceRoot += "/";
+      }
+      sourceURL = sourceRoot + sourceURL;
+    }
+    if (sourceMapURL) {
+      var parsed = urlParse(sourceMapURL);
+      if (!parsed) {
+        throw new Error("sourceMapURL could not be parsed");
+      }
+      if (parsed.path) {
+        var index = parsed.path.lastIndexOf("/");
+        if (index >= 0) {
+          parsed.path = parsed.path.substring(0, index + 1);
+        }
+      }
+      sourceURL = join(urlGenerate(parsed), sourceURL);
+    }
+    return normalize(sourceURL);
+  }
+  exports.computeSourceURL = computeSourceURL;
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/array-set.js
+var require_array_set = __commonJS((exports) => {
+  var util = require_util();
+  var has = Object.prototype.hasOwnProperty;
+  var hasNativeMap = typeof Map !== "undefined";
+  function ArraySet() {
+    this._array = [];
+    this._set = hasNativeMap ? new Map : Object.create(null);
+  }
+  ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+    var set = new ArraySet;
+    for (var i = 0, len = aArray.length;i < len; i++) {
+      set.add(aArray[i], aAllowDuplicates);
+    }
+    return set;
+  };
+  ArraySet.prototype.size = function ArraySet_size() {
+    return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+  };
+  ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+    var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
+    var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+    var idx = this._array.length;
+    if (!isDuplicate || aAllowDuplicates) {
+      this._array.push(aStr);
+    }
+    if (!isDuplicate) {
+      if (hasNativeMap) {
+        this._set.set(aStr, idx);
+      } else {
+        this._set[sStr] = idx;
+      }
+    }
+  };
+  ArraySet.prototype.has = function ArraySet_has(aStr) {
+    if (hasNativeMap) {
+      return this._set.has(aStr);
+    } else {
+      var sStr = util.toSetString(aStr);
+      return has.call(this._set, sStr);
+    }
+  };
+  ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+    if (hasNativeMap) {
+      var idx = this._set.get(aStr);
+      if (idx >= 0) {
+        return idx;
+      }
+    } else {
+      var sStr = util.toSetString(aStr);
+      if (has.call(this._set, sStr)) {
+        return this._set[sStr];
+      }
+    }
+    throw new Error('"' + aStr + '" is not in the set.');
+  };
+  ArraySet.prototype.at = function ArraySet_at(aIdx) {
+    if (aIdx >= 0 && aIdx < this._array.length) {
+      return this._array[aIdx];
+    }
+    throw new Error("No element indexed by " + aIdx);
+  };
+  ArraySet.prototype.toArray = function ArraySet_toArray() {
+    return this._array.slice();
+  };
+  exports.ArraySet = ArraySet;
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/mapping-list.js
+var require_mapping_list = __commonJS((exports) => {
+  var util = require_util();
+  function generatedPositionAfter(mappingA, mappingB) {
+    var lineA = mappingA.generatedLine;
+    var lineB = mappingB.generatedLine;
+    var columnA = mappingA.generatedColumn;
+    var columnB = mappingB.generatedColumn;
+    return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+  }
+  function MappingList() {
+    this._array = [];
+    this._sorted = true;
+    this._last = { generatedLine: -1, generatedColumn: 0 };
+  }
+  MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
+    this._array.forEach(aCallback, aThisArg);
+  };
+  MappingList.prototype.add = function MappingList_add(aMapping) {
+    if (generatedPositionAfter(this._last, aMapping)) {
+      this._last = aMapping;
+      this._array.push(aMapping);
+    } else {
+      this._sorted = false;
+      this._array.push(aMapping);
+    }
+  };
+  MappingList.prototype.toArray = function MappingList_toArray() {
+    if (!this._sorted) {
+      this._array.sort(util.compareByGeneratedPositionsInflated);
+      this._sorted = true;
+    }
+    return this._array;
+  };
+  exports.MappingList = MappingList;
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/source-map-generator.js
+var require_source_map_generator = __commonJS((exports) => {
+  var base64VLQ = require_base64_vlq();
+  var util = require_util();
+  var ArraySet = require_array_set().ArraySet;
+  var MappingList = require_mapping_list().MappingList;
+  function SourceMapGenerator(aArgs) {
+    if (!aArgs) {
+      aArgs = {};
+    }
+    this._file = util.getArg(aArgs, "file", null);
+    this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
+    this._skipValidation = util.getArg(aArgs, "skipValidation", false);
+    this._ignoreInvalidMapping = util.getArg(aArgs, "ignoreInvalidMapping", false);
+    this._sources = new ArraySet;
+    this._names = new ArraySet;
+    this._mappings = new MappingList;
+    this._sourcesContents = null;
+  }
+  SourceMapGenerator.prototype._version = 3;
+  SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {
+    var sourceRoot = aSourceMapConsumer.sourceRoot;
+    var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {
+      file: aSourceMapConsumer.file,
+      sourceRoot
+    }));
+    aSourceMapConsumer.eachMapping(function(mapping) {
+      var newMapping = {
+        generated: {
+          line: mapping.generatedLine,
+          column: mapping.generatedColumn
+        }
+      };
+      if (mapping.source != null) {
+        newMapping.source = mapping.source;
+        if (sourceRoot != null) {
+          newMapping.source = util.relative(sourceRoot, newMapping.source);
+        }
+        newMapping.original = {
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        };
+        if (mapping.name != null) {
+          newMapping.name = mapping.name;
+        }
+      }
+      generator.addMapping(newMapping);
+    });
+    aSourceMapConsumer.sources.forEach(function(sourceFile) {
+      var sourceRelative = sourceFile;
+      if (sourceRoot !== null) {
+        sourceRelative = util.relative(sourceRoot, sourceFile);
+      }
+      if (!generator._sources.has(sourceRelative)) {
+        generator._sources.add(sourceRelative);
+      }
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        generator.setSourceContent(sourceFile, content);
+      }
+    });
+    return generator;
+  };
+  SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
+    var generated = util.getArg(aArgs, "generated");
+    var original = util.getArg(aArgs, "original", null);
+    var source = util.getArg(aArgs, "source", null);
+    var name = util.getArg(aArgs, "name", null);
+    if (!this._skipValidation) {
+      if (this._validateMapping(generated, original, source, name) === false) {
+        return;
+      }
+    }
+    if (source != null) {
+      source = String(source);
+      if (!this._sources.has(source)) {
+        this._sources.add(source);
+      }
+    }
+    if (name != null) {
+      name = String(name);
+      if (!this._names.has(name)) {
+        this._names.add(name);
+      }
+    }
+    this._mappings.add({
+      generatedLine: generated.line,
+      generatedColumn: generated.column,
+      originalLine: original != null && original.line,
+      originalColumn: original != null && original.column,
+      source,
+      name
+    });
+  };
+  SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+    var source = aSourceFile;
+    if (this._sourceRoot != null) {
+      source = util.relative(this._sourceRoot, source);
+    }
+    if (aSourceContent != null) {
+      if (!this._sourcesContents) {
+        this._sourcesContents = Object.create(null);
+      }
+      this._sourcesContents[util.toSetString(source)] = aSourceContent;
+    } else if (this._sourcesContents) {
+      delete this._sourcesContents[util.toSetString(source)];
+      if (Object.keys(this._sourcesContents).length === 0) {
+        this._sourcesContents = null;
+      }
+    }
+  };
+  SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+    var sourceFile = aSourceFile;
+    if (aSourceFile == null) {
+      if (aSourceMapConsumer.file == null) {
+        throw new Error("SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " + `or the source map's "file" property. Both were omitted.`);
+      }
+      sourceFile = aSourceMapConsumer.file;
+    }
+    var sourceRoot = this._sourceRoot;
+    if (sourceRoot != null) {
+      sourceFile = util.relative(sourceRoot, sourceFile);
+    }
+    var newSources = new ArraySet;
+    var newNames = new ArraySet;
+    this._mappings.unsortedForEach(function(mapping) {
+      if (mapping.source === sourceFile && mapping.originalLine != null) {
+        var original = aSourceMapConsumer.originalPositionFor({
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        });
+        if (original.source != null) {
+          mapping.source = original.source;
+          if (aSourceMapPath != null) {
+            mapping.source = util.join(aSourceMapPath, mapping.source);
+          }
+          if (sourceRoot != null) {
+            mapping.source = util.relative(sourceRoot, mapping.source);
+          }
+          mapping.originalLine = original.line;
+          mapping.originalColumn = original.column;
+          if (original.name != null) {
+            mapping.name = original.name;
+          }
+        }
+      }
+      var source = mapping.source;
+      if (source != null && !newSources.has(source)) {
+        newSources.add(source);
+      }
+      var name = mapping.name;
+      if (name != null && !newNames.has(name)) {
+        newNames.add(name);
+      }
+    }, this);
+    this._sources = newSources;
+    this._names = newNames;
+    aSourceMapConsumer.sources.forEach(function(sourceFile2) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
+      if (content != null) {
+        if (aSourceMapPath != null) {
+          sourceFile2 = util.join(aSourceMapPath, sourceFile2);
+        }
+        if (sourceRoot != null) {
+          sourceFile2 = util.relative(sourceRoot, sourceFile2);
+        }
+        this.setSourceContent(sourceFile2, content);
+      }
+    }, this);
+  };
+  SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
+    if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
+      var message = "original.line and original.column are not numbers -- you probably meant to omit " + "the original mapping entirely and only map the generated position. If so, pass " + "null for the original mapping instead of an object with empty or null values.";
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+    if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
+      return;
+    } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
+      return;
+    } else {
+      var message = "Invalid mapping: " + JSON.stringify({
+        generated: aGenerated,
+        source: aSource,
+        original: aOriginal,
+        name: aName
+      });
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+  };
+  SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
+    var previousGeneratedColumn = 0;
+    var previousGeneratedLine = 1;
+    var previousOriginalColumn = 0;
+    var previousOriginalLine = 0;
+    var previousName = 0;
+    var previousSource = 0;
+    var result = "";
+    var next;
+    var mapping;
+    var nameIdx;
+    var sourceIdx;
+    var mappings = this._mappings.toArray();
+    for (var i = 0, len = mappings.length;i < len; i++) {
+      mapping = mappings[i];
+      next = "";
+      if (mapping.generatedLine !== previousGeneratedLine) {
+        previousGeneratedColumn = 0;
+        while (mapping.generatedLine !== previousGeneratedLine) {
+          next += ";";
+          previousGeneratedLine++;
+        }
+      } else {
+        if (i > 0) {
+          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+            continue;
+          }
+          next += ",";
+        }
+      }
+      next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
+      previousGeneratedColumn = mapping.generatedColumn;
+      if (mapping.source != null) {
+        sourceIdx = this._sources.indexOf(mapping.source);
+        next += base64VLQ.encode(sourceIdx - previousSource);
+        previousSource = sourceIdx;
+        next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
+        previousOriginalLine = mapping.originalLine - 1;
+        next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
+        previousOriginalColumn = mapping.originalColumn;
+        if (mapping.name != null) {
+          nameIdx = this._names.indexOf(mapping.name);
+          next += base64VLQ.encode(nameIdx - previousName);
+          previousName = nameIdx;
+        }
+      }
+      result += next;
+    }
+    return result;
+  };
+  SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+    return aSources.map(function(source) {
+      if (!this._sourcesContents) {
+        return null;
+      }
+      if (aSourceRoot != null) {
+        source = util.relative(aSourceRoot, source);
+      }
+      var key = util.toSetString(source);
+      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
+    }, this);
+  };
+  SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
+    var map = {
+      version: this._version,
+      sources: this._sources.toArray(),
+      names: this._names.toArray(),
+      mappings: this._serializeMappings()
+    };
+    if (this._file != null) {
+      map.file = this._file;
+    }
+    if (this._sourceRoot != null) {
+      map.sourceRoot = this._sourceRoot;
+    }
+    if (this._sourcesContents) {
+      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+    }
+    return map;
+  };
+  SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
+    return JSON.stringify(this.toJSON());
+  };
+  exports.SourceMapGenerator = SourceMapGenerator;
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/binary-search.js
+var require_binary_search = __commonJS((exports) => {
+  exports.GREATEST_LOWER_BOUND = 1;
+  exports.LEAST_UPPER_BOUND = 2;
+  function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+    var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+    var cmp = aCompare(aNeedle, aHaystack[mid], true);
+    if (cmp === 0) {
+      return mid;
+    } else if (cmp > 0) {
+      if (aHigh - mid > 1) {
+        return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+      }
+      if (aBias == exports.LEAST_UPPER_BOUND) {
+        return aHigh < aHaystack.length ? aHigh : -1;
+      } else {
+        return mid;
+      }
+    } else {
+      if (mid - aLow > 1) {
+        return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+      }
+      if (aBias == exports.LEAST_UPPER_BOUND) {
+        return mid;
+      } else {
+        return aLow < 0 ? -1 : aLow;
+      }
+    }
+  }
+  exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+    if (aHaystack.length === 0) {
+      return -1;
+    }
+    var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND);
+    if (index < 0) {
+      return -1;
+    }
+    while (index - 1 >= 0) {
+      if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+        break;
+      }
+      --index;
+    }
+    return index;
+  };
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/quick-sort.js
+var require_quick_sort = __commonJS((exports) => {
+  function SortTemplate(comparator) {
+    function swap(ary, x, y) {
+      var temp = ary[x];
+      ary[x] = ary[y];
+      ary[y] = temp;
+    }
+    function randomIntInRange(low, high) {
+      return Math.round(low + Math.random() * (high - low));
+    }
+    function doQuickSort(ary, comparator2, p, r) {
+      if (p < r) {
+        var pivotIndex = randomIntInRange(p, r);
+        var i = p - 1;
+        swap(ary, pivotIndex, r);
+        var pivot = ary[r];
+        for (var j = p;j < r; j++) {
+          if (comparator2(ary[j], pivot, false) <= 0) {
+            i += 1;
+            swap(ary, i, j);
+          }
+        }
+        swap(ary, i + 1, j);
+        var q = i + 1;
+        doQuickSort(ary, comparator2, p, q - 1);
+        doQuickSort(ary, comparator2, q + 1, r);
+      }
+    }
+    return doQuickSort;
+  }
+  function cloneSort(comparator) {
+    let template = SortTemplate.toString();
+    let templateFn = new Function(`return ${template}`)();
+    return templateFn(comparator);
+  }
+  var sortCache = new WeakMap;
+  exports.quickSort = function(ary, comparator, start = 0) {
+    let doQuickSort = sortCache.get(comparator);
+    if (doQuickSort === undefined) {
+      doQuickSort = cloneSort(comparator);
+      sortCache.set(comparator, doQuickSort);
+    }
+    doQuickSort(ary, comparator, start, ary.length - 1);
+  };
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/source-map-consumer.js
+var require_source_map_consumer = __commonJS((exports) => {
+  var util = require_util();
+  var binarySearch = require_binary_search();
+  var ArraySet = require_array_set().ArraySet;
+  var base64VLQ = require_base64_vlq();
+  var quickSort = require_quick_sort().quickSort;
+  function SourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap = util.parseSourceMapInput(aSourceMap);
+    }
+    return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+  }
+  SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
+    return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+  };
+  SourceMapConsumer.prototype._version = 3;
+  SourceMapConsumer.prototype.__generatedMappings = null;
+  Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
+    configurable: true,
+    enumerable: true,
+    get: function() {
+      if (!this.__generatedMappings) {
+        this._parseMappings(this._mappings, this.sourceRoot);
+      }
+      return this.__generatedMappings;
+    }
+  });
+  SourceMapConsumer.prototype.__originalMappings = null;
+  Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
+    configurable: true,
+    enumerable: true,
+    get: function() {
+      if (!this.__originalMappings) {
+        this._parseMappings(this._mappings, this.sourceRoot);
+      }
+      return this.__originalMappings;
+    }
+  });
+  SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+    var c = aStr.charAt(index);
+    return c === ";" || c === ",";
+  };
+  SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    throw new Error("Subclasses must implement _parseMappings");
+  };
+  SourceMapConsumer.GENERATED_ORDER = 1;
+  SourceMapConsumer.ORIGINAL_ORDER = 2;
+  SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+  SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+  SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+    var context = aContext || null;
+    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+    var mappings;
+    switch (order) {
+      case SourceMapConsumer.GENERATED_ORDER:
+        mappings = this._generatedMappings;
+        break;
+      case SourceMapConsumer.ORIGINAL_ORDER:
+        mappings = this._originalMappings;
+        break;
+      default:
+        throw new Error("Unknown order of iteration.");
+    }
+    var sourceRoot = this.sourceRoot;
+    var boundCallback = aCallback.bind(context);
+    var names = this._names;
+    var sources = this._sources;
+    var sourceMapURL = this._sourceMapURL;
+    for (var i = 0, n = mappings.length;i < n; i++) {
+      var mapping = mappings[i];
+      var source = mapping.source === null ? null : sources.at(mapping.source);
+      if (source !== null) {
+        source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
+      }
+      boundCallback({
+        source,
+        generatedLine: mapping.generatedLine,
+        generatedColumn: mapping.generatedColumn,
+        originalLine: mapping.originalLine,
+        originalColumn: mapping.originalColumn,
+        name: mapping.name === null ? null : names.at(mapping.name)
+      });
+    }
+  };
+  SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+    var line = util.getArg(aArgs, "line");
+    var needle = {
+      source: util.getArg(aArgs, "source"),
+      originalLine: line,
+      originalColumn: util.getArg(aArgs, "column", 0)
+    };
+    needle.source = this._findSourceIndex(needle.source);
+    if (needle.source < 0) {
+      return [];
+    }
+    var mappings = [];
+    var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+      if (aArgs.column === undefined) {
+        var originalLine = mapping.originalLine;
+        while (mapping && mapping.originalLine === originalLine) {
+          mappings.push({
+            line: util.getArg(mapping, "generatedLine", null),
+            column: util.getArg(mapping, "generatedColumn", null),
+            lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+          });
+          mapping = this._originalMappings[++index];
+        }
+      } else {
+        var originalColumn = mapping.originalColumn;
+        while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
+          mappings.push({
+            line: util.getArg(mapping, "generatedLine", null),
+            column: util.getArg(mapping, "generatedColumn", null),
+            lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+          });
+          mapping = this._originalMappings[++index];
+        }
+      }
+    }
+    return mappings;
+  };
+  exports.SourceMapConsumer = SourceMapConsumer;
+  function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap = util.parseSourceMapInput(aSourceMap);
+    }
+    var version = util.getArg(sourceMap, "version");
+    var sources = util.getArg(sourceMap, "sources");
+    var names = util.getArg(sourceMap, "names", []);
+    var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
+    var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
+    var mappings = util.getArg(sourceMap, "mappings");
+    var file = util.getArg(sourceMap, "file", null);
+    if (version != this._version) {
+      throw new Error("Unsupported version: " + version);
+    }
+    if (sourceRoot) {
+      sourceRoot = util.normalize(sourceRoot);
+    }
+    sources = sources.map(String).map(util.normalize).map(function(source) {
+      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
+    });
+    this._names = ArraySet.fromArray(names.map(String), true);
+    this._sources = ArraySet.fromArray(sources, true);
+    this._absoluteSources = this._sources.toArray().map(function(s) {
+      return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+    });
+    this.sourceRoot = sourceRoot;
+    this.sourcesContent = sourcesContent;
+    this._mappings = mappings;
+    this._sourceMapURL = aSourceMapURL;
+    this.file = file;
+  }
+  BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+  BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+  BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
+    var relativeSource = aSource;
+    if (this.sourceRoot != null) {
+      relativeSource = util.relative(this.sourceRoot, relativeSource);
+    }
+    if (this._sources.has(relativeSource)) {
+      return this._sources.indexOf(relativeSource);
+    }
+    var i;
+    for (i = 0;i < this._absoluteSources.length; ++i) {
+      if (this._absoluteSources[i] == aSource) {
+        return i;
+      }
+    }
+    return -1;
+  };
+  BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
+    var smc = Object.create(BasicSourceMapConsumer.prototype);
+    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+    smc.sourceRoot = aSourceMap._sourceRoot;
+    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
+    smc.file = aSourceMap._file;
+    smc._sourceMapURL = aSourceMapURL;
+    smc._absoluteSources = smc._sources.toArray().map(function(s) {
+      return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
+    });
+    var generatedMappings = aSourceMap._mappings.toArray().slice();
+    var destGeneratedMappings = smc.__generatedMappings = [];
+    var destOriginalMappings = smc.__originalMappings = [];
+    for (var i = 0, length = generatedMappings.length;i < length; i++) {
+      var srcMapping = generatedMappings[i];
+      var destMapping = new Mapping;
+      destMapping.generatedLine = srcMapping.generatedLine;
+      destMapping.generatedColumn = srcMapping.generatedColumn;
+      if (srcMapping.source) {
+        destMapping.source = sources.indexOf(srcMapping.source);
+        destMapping.originalLine = srcMapping.originalLine;
+        destMapping.originalColumn = srcMapping.originalColumn;
+        if (srcMapping.name) {
+          destMapping.name = names.indexOf(srcMapping.name);
+        }
+        destOriginalMappings.push(destMapping);
+      }
+      destGeneratedMappings.push(destMapping);
+    }
+    quickSort(smc.__originalMappings, util.compareByOriginalPositions);
+    return smc;
+  };
+  BasicSourceMapConsumer.prototype._version = 3;
+  Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
+    get: function() {
+      return this._absoluteSources.slice();
+    }
+  });
+  function Mapping() {
+    this.generatedLine = 0;
+    this.generatedColumn = 0;
+    this.source = null;
+    this.originalLine = null;
+    this.originalColumn = null;
+    this.name = null;
+  }
+  var compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
+  function sortGenerated(array, start) {
+    let l = array.length;
+    let n = array.length - start;
+    if (n <= 1) {
+      return;
+    } else if (n == 2) {
+      let a = array[start];
+      let b = array[start + 1];
+      if (compareGenerated(a, b) > 0) {
+        array[start] = b;
+        array[start + 1] = a;
+      }
+    } else if (n < 20) {
+      for (let i = start;i < l; i++) {
+        for (let j = i;j > start; j--) {
+          let a = array[j - 1];
+          let b = array[j];
+          if (compareGenerated(a, b) <= 0) {
+            break;
+          }
+          array[j - 1] = b;
+          array[j] = a;
+        }
+      }
+    } else {
+      quickSort(array, compareGenerated, start);
+    }
+  }
+  BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    var generatedLine = 1;
+    var previousGeneratedColumn = 0;
+    var previousOriginalLine = 0;
+    var previousOriginalColumn = 0;
+    var previousSource = 0;
+    var previousName = 0;
+    var length = aStr.length;
+    var index = 0;
+    var cachedSegments = {};
+    var temp = {};
+    var originalMappings = [];
+    var generatedMappings = [];
+    var mapping, str, segment, end, value;
+    let subarrayStart = 0;
+    while (index < length) {
+      if (aStr.charAt(index) === ";") {
+        generatedLine++;
+        index++;
+        previousGeneratedColumn = 0;
+        sortGenerated(generatedMappings, subarrayStart);
+        subarrayStart = generatedMappings.length;
+      } else if (aStr.charAt(index) === ",") {
+        index++;
+      } else {
+        mapping = new Mapping;
+        mapping.generatedLine = generatedLine;
+        for (end = index;end < length; end++) {
+          if (this._charIsMappingSeparator(aStr, end)) {
+            break;
+          }
+        }
+        str = aStr.slice(index, end);
+        segment = [];
+        while (index < end) {
+          base64VLQ.decode(aStr, index, temp);
+          value = temp.value;
+          index = temp.rest;
+          segment.push(value);
+        }
+        if (segment.length === 2) {
+          throw new Error("Found a source, but no line and column");
+        }
+        if (segment.length === 3) {
+          throw new Error("Found a source and line, but no column");
+        }
+        mapping.generatedColumn = previousGeneratedColumn + segment[0];
+        previousGeneratedColumn = mapping.generatedColumn;
+        if (segment.length > 1) {
+          mapping.source = previousSource + segment[1];
+          previousSource += segment[1];
+          mapping.originalLine = previousOriginalLine + segment[2];
+          previousOriginalLine = mapping.originalLine;
+          mapping.originalLine += 1;
+          mapping.originalColumn = previousOriginalColumn + segment[3];
+          previousOriginalColumn = mapping.originalColumn;
+          if (segment.length > 4) {
+            mapping.name = previousName + segment[4];
+            previousName += segment[4];
+          }
+        }
+        generatedMappings.push(mapping);
+        if (typeof mapping.originalLine === "number") {
+          let currentSource = mapping.source;
+          while (originalMappings.length <= currentSource) {
+            originalMappings.push(null);
+          }
+          if (originalMappings[currentSource] === null) {
+            originalMappings[currentSource] = [];
+          }
+          originalMappings[currentSource].push(mapping);
+        }
+      }
+    }
+    sortGenerated(generatedMappings, subarrayStart);
+    this.__generatedMappings = generatedMappings;
+    for (var i = 0;i < originalMappings.length; i++) {
+      if (originalMappings[i] != null) {
+        quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
+      }
+    }
+    this.__originalMappings = [].concat(...originalMappings);
+  };
+  BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
+    if (aNeedle[aLineName] <= 0) {
+      throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
+    }
+    if (aNeedle[aColumnName] < 0) {
+      throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
+    }
+    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+  };
+  BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
+    for (var index = 0;index < this._generatedMappings.length; ++index) {
+      var mapping = this._generatedMappings[index];
+      if (index + 1 < this._generatedMappings.length) {
+        var nextMapping = this._generatedMappings[index + 1];
+        if (mapping.generatedLine === nextMapping.generatedLine) {
+          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+          continue;
+        }
+      }
+      mapping.lastGeneratedColumn = Infinity;
+    }
+  };
+  BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, "line"),
+      generatedColumn: util.getArg(aArgs, "column")
+    };
+    var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
+    if (index >= 0) {
+      var mapping = this._generatedMappings[index];
+      if (mapping.generatedLine === needle.generatedLine) {
+        var source = util.getArg(mapping, "source", null);
+        if (source !== null) {
+          source = this._sources.at(source);
+          source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+        }
+        var name = util.getArg(mapping, "name", null);
+        if (name !== null) {
+          name = this._names.at(name);
+        }
+        return {
+          source,
+          line: util.getArg(mapping, "originalLine", null),
+          column: util.getArg(mapping, "originalColumn", null),
+          name
+        };
+      }
+    }
+    return {
+      source: null,
+      line: null,
+      column: null,
+      name: null
+    };
+  };
+  BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
+    if (!this.sourcesContent) {
+      return false;
+    }
+    return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
+      return sc == null;
+    });
+  };
+  BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    if (!this.sourcesContent) {
+      return null;
+    }
+    var index = this._findSourceIndex(aSource);
+    if (index >= 0) {
+      return this.sourcesContent[index];
+    }
+    var relativeSource = aSource;
+    if (this.sourceRoot != null) {
+      relativeSource = util.relative(this.sourceRoot, relativeSource);
+    }
+    var url;
+    if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
+      var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
+      if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) {
+        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
+      }
+      if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) {
+        return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
+      }
+    }
+    if (nullOnMissing) {
+      return null;
+    } else {
+      throw new Error('"' + relativeSource + '" is not in the SourceMap.');
+    }
+  };
+  BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
+    var source = util.getArg(aArgs, "source");
+    source = this._findSourceIndex(source);
+    if (source < 0) {
+      return {
+        line: null,
+        column: null,
+        lastColumn: null
+      };
+    }
+    var needle = {
+      source,
+      originalLine: util.getArg(aArgs, "line"),
+      originalColumn: util.getArg(aArgs, "column")
+    };
+    var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+      if (mapping.source === needle.source) {
+        return {
+          line: util.getArg(mapping, "generatedLine", null),
+          column: util.getArg(mapping, "generatedColumn", null),
+          lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+        };
+      }
+    }
+    return {
+      line: null,
+      column: null,
+      lastColumn: null
+    };
+  };
+  exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+  function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap = util.parseSourceMapInput(aSourceMap);
+    }
+    var version = util.getArg(sourceMap, "version");
+    var sections = util.getArg(sourceMap, "sections");
+    if (version != this._version) {
+      throw new Error("Unsupported version: " + version);
+    }
+    this._sources = new ArraySet;
+    this._names = new ArraySet;
+    var lastOffset = {
+      line: -1,
+      column: 0
+    };
+    this._sections = sections.map(function(s) {
+      if (s.url) {
+        throw new Error("Support for url field in sections not implemented.");
+      }
+      var offset = util.getArg(s, "offset");
+      var offsetLine = util.getArg(offset, "line");
+      var offsetColumn = util.getArg(offset, "column");
+      if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
+        throw new Error("Section offsets must be ordered and non-overlapping.");
+      }
+      lastOffset = offset;
+      return {
+        generatedOffset: {
+          generatedLine: offsetLine + 1,
+          generatedColumn: offsetColumn + 1
+        },
+        consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
+      };
+    });
+  }
+  IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+  IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+  IndexedSourceMapConsumer.prototype._version = 3;
+  Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
+    get: function() {
+      var sources = [];
+      for (var i = 0;i < this._sections.length; i++) {
+        for (var j = 0;j < this._sections[i].consumer.sources.length; j++) {
+          sources.push(this._sections[i].consumer.sources[j]);
+        }
+      }
+      return sources;
+    }
+  });
+  IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, "line"),
+      generatedColumn: util.getArg(aArgs, "column")
+    };
+    var sectionIndex = binarySearch.search(needle, this._sections, function(needle2, section2) {
+      var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
+      if (cmp) {
+        return cmp;
+      }
+      return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
+    });
+    var section = this._sections[sectionIndex];
+    if (!section) {
+      return {
+        source: null,
+        line: null,
+        column: null,
+        name: null
+      };
+    }
+    return section.consumer.originalPositionFor({
+      line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
+      column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+      bias: aArgs.bias
+    });
+  };
+  IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
+    return this._sections.every(function(s) {
+      return s.consumer.hasContentsOfAllSources();
+    });
+  };
+  IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    for (var i = 0;i < this._sections.length; i++) {
+      var section = this._sections[i];
+      var content = section.consumer.sourceContentFor(aSource, true);
+      if (content || content === "") {
+        return content;
+      }
+    }
+    if (nullOnMissing) {
+      return null;
+    } else {
+      throw new Error('"' + aSource + '" is not in the SourceMap.');
+    }
+  };
+  IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+    for (var i = 0;i < this._sections.length; i++) {
+      var section = this._sections[i];
+      if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
+        continue;
+      }
+      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+      if (generatedPosition) {
+        var ret = {
+          line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
+          column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
+        };
+        return ret;
+      }
+    }
+    return {
+      line: null,
+      column: null
+    };
+  };
+  IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    this.__generatedMappings = [];
+    this.__originalMappings = [];
+    for (var i = 0;i < this._sections.length; i++) {
+      var section = this._sections[i];
+      var sectionMappings = section.consumer._generatedMappings;
+      for (var j = 0;j < sectionMappings.length; j++) {
+        var mapping = sectionMappings[j];
+        var source = section.consumer._sources.at(mapping.source);
+        if (source !== null) {
+          source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
+        }
+        this._sources.add(source);
+        source = this._sources.indexOf(source);
+        var name = null;
+        if (mapping.name) {
+          name = section.consumer._names.at(mapping.name);
+          this._names.add(name);
+          name = this._names.indexOf(name);
+        }
+        var adjustedMapping = {
+          source,
+          generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
+          generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+          originalLine: mapping.originalLine,
+          originalColumn: mapping.originalColumn,
+          name
+        };
+        this.__generatedMappings.push(adjustedMapping);
+        if (typeof adjustedMapping.originalLine === "number") {
+          this.__originalMappings.push(adjustedMapping);
+        }
+      }
+    }
+    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+    quickSort(this.__originalMappings, util.compareByOriginalPositions);
+  };
+  exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
+});
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/lib/source-node.js
+var require_source_node = __commonJS((exports) => {
+  var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
+  var util = require_util();
+  var REGEX_NEWLINE = /(\r?\n)/;
+  var NEWLINE_CODE = 10;
+  var isSourceNode = "$$$isSourceNode$$$";
+  function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+    this.children = [];
+    this.sourceContents = {};
+    this.line = aLine == null ? null : aLine;
+    this.column = aColumn == null ? null : aColumn;
+    this.source = aSource == null ? null : aSource;
+    this.name = aName == null ? null : aName;
+    this[isSourceNode] = true;
+    if (aChunks != null)
+      this.add(aChunks);
+  }
+  SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+    var node = new SourceNode;
+    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+    var remainingLinesIndex = 0;
+    var shiftNextLine = function() {
+      var lineContents = getNextLine();
+      var newLine = getNextLine() || "";
+      return lineContents + newLine;
+      function getNextLine() {
+        return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : undefined;
+      }
+    };
+    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+    var lastMapping = null;
+    aSourceMapConsumer.eachMapping(function(mapping) {
+      if (lastMapping !== null) {
+        if (lastGeneratedLine < mapping.generatedLine) {
+          addMappingWithCode(lastMapping, shiftNextLine());
+          lastGeneratedLine++;
+          lastGeneratedColumn = 0;
+        } else {
+          var nextLine = remainingLines[remainingLinesIndex] || "";
+          var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
+          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
+          lastGeneratedColumn = mapping.generatedColumn;
+          addMappingWithCode(lastMapping, code);
+          lastMapping = mapping;
+          return;
+        }
+      }
+      while (lastGeneratedLine < mapping.generatedLine) {
+        node.add(shiftNextLine());
+        lastGeneratedLine++;
+      }
+      if (lastGeneratedColumn < mapping.generatedColumn) {
+        var nextLine = remainingLines[remainingLinesIndex] || "";
+        node.add(nextLine.substr(0, mapping.generatedColumn));
+        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+        lastGeneratedColumn = mapping.generatedColumn;
+      }
+      lastMapping = mapping;
+    }, this);
+    if (remainingLinesIndex < remainingLines.length) {
+      if (lastMapping) {
+        addMappingWithCode(lastMapping, shiftNextLine());
+      }
+      node.add(remainingLines.splice(remainingLinesIndex).join(""));
+    }
+    aSourceMapConsumer.sources.forEach(function(sourceFile) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        if (aRelativePath != null) {
+          sourceFile = util.join(aRelativePath, sourceFile);
+        }
+        node.setSourceContent(sourceFile, content);
+      }
+    });
+    return node;
+    function addMappingWithCode(mapping, code) {
+      if (mapping === null || mapping.source === undefined) {
+        node.add(code);
+      } else {
+        var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
+        node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
+      }
+    }
+  };
+  SourceNode.prototype.add = function SourceNode_add(aChunk) {
+    if (Array.isArray(aChunk)) {
+      aChunk.forEach(function(chunk) {
+        this.add(chunk);
+      }, this);
+    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      if (aChunk) {
+        this.children.push(aChunk);
+      }
+    } else {
+      throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
+    }
+    return this;
+  };
+  SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+    if (Array.isArray(aChunk)) {
+      for (var i = aChunk.length - 1;i >= 0; i--) {
+        this.prepend(aChunk[i]);
+      }
+    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      this.children.unshift(aChunk);
+    } else {
+      throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
+    }
+    return this;
+  };
+  SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+    var chunk;
+    for (var i = 0, len = this.children.length;i < len; i++) {
+      chunk = this.children[i];
+      if (chunk[isSourceNode]) {
+        chunk.walk(aFn);
+      } else {
+        if (chunk !== "") {
+          aFn(chunk, {
+            source: this.source,
+            line: this.line,
+            column: this.column,
+            name: this.name
+          });
+        }
+      }
+    }
+  };
+  SourceNode.prototype.join = function SourceNode_join(aSep) {
+    var newChildren;
+    var i;
+    var len = this.children.length;
+    if (len > 0) {
+      newChildren = [];
+      for (i = 0;i < len - 1; i++) {
+        newChildren.push(this.children[i]);
+        newChildren.push(aSep);
+      }
+      newChildren.push(this.children[i]);
+      this.children = newChildren;
+    }
+    return this;
+  };
+  SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+    var lastChild = this.children[this.children.length - 1];
+    if (lastChild[isSourceNode]) {
+      lastChild.replaceRight(aPattern, aReplacement);
+    } else if (typeof lastChild === "string") {
+      this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+    } else {
+      this.children.push("".replace(aPattern, aReplacement));
+    }
+    return this;
+  };
+  SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+  };
+  SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
+    for (var i = 0, len = this.children.length;i < len; i++) {
+      if (this.children[i][isSourceNode]) {
+        this.children[i].walkSourceContents(aFn);
+      }
+    }
+    var sources = Object.keys(this.sourceContents);
+    for (var i = 0, len = sources.length;i < len; i++) {
+      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+    }
+  };
+  SourceNode.prototype.toString = function SourceNode_toString() {
+    var str = "";
+    this.walk(function(chunk) {
+      str += chunk;
+    });
+    return str;
+  };
+  SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+    var generated = {
+      code: "",
+      line: 1,
+      column: 0
+    };
+    var map = new SourceMapGenerator(aArgs);
+    var sourceMappingActive = false;
+    var lastOriginalSource = null;
+    var lastOriginalLine = null;
+    var lastOriginalColumn = null;
+    var lastOriginalName = null;
+    this.walk(function(chunk, original) {
+      generated.code += chunk;
+      if (original.source !== null && original.line !== null && original.column !== null) {
+        if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+        lastOriginalSource = original.source;
+        lastOriginalLine = original.line;
+        lastOriginalColumn = original.column;
+        lastOriginalName = original.name;
+        sourceMappingActive = true;
+      } else if (sourceMappingActive) {
+        map.addMapping({
+          generated: {
+            line: generated.line,
+            column: generated.column
+          }
+        });
+        lastOriginalSource = null;
+        sourceMappingActive = false;
+      }
+      for (var idx = 0, length = chunk.length;idx < length; idx++) {
+        if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+          generated.line++;
+          generated.column = 0;
+          if (idx + 1 === length) {
+            lastOriginalSource = null;
+            sourceMappingActive = false;
+          } else if (sourceMappingActive) {
+            map.addMapping({
+              source: original.source,
+              original: {
+                line: original.line,
+                column: original.column
+              },
+              generated: {
+                line: generated.line,
+                column: generated.column
+              },
+              name: original.name
+            });
+          }
+        } else {
+          generated.column++;
+        }
+      }
+    });
+    this.walkSourceContents(function(sourceFile, sourceContent) {
+      map.setSourceContent(sourceFile, sourceContent);
+    });
+    return { code: generated.code, map };
+  };
+  exports.SourceNode = SourceNode;
+});
 
 // src/devtools/core/ActionDevtoolsCore.ts
 function extractRouting(context) {
@@ -128,11 +1937,17 @@ class ActionDevtoolsCore {
   }
 }
 // src/devtools/browser/NiceActionDevtools.tsx
-import { useCallback, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState6 } from "react";
+import { useCallback, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef2, useState as useState6 } from "react";
 
 // src/devtools/browser/components/ActionDetailPanel.tsx
 import { useMemo, useState as useState5 } from "react";
 
+// src/devtools/core/devtools_colors.ts
+var DEVTOOL_COLOR_HANDLER_LOCAL_TEXT = "#34bb89";
+var DEVTOOL_COLOR_HANDLER_LOCAL_BORDER = "#144427";
+var DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT = "#cfa12a";
+var DEVTOOL_COLOR_HANDLER_EXTERNAL_BORDER = "#723917";
+
 // src/devtools/browser/components/DomainChip.tsx
 import { createContext, useContext, useRef } from "react";
 import { jsxDEV } from "react/jsx-dev-runtime";
@@ -226,19 +2041,79 @@ function DomainChip({
       whiteSpace: "nowrap"
     },
     children: [
-      /* @__PURE__ */ jsxDEV("span", {
-        style: {
-          fontSize: size === "md" ? "0.9rem" : "0.8rem",
-          height: "0.6em",
-          width: "0.6em",
-          display: "flex",
-          alignItems: "center",
-          justifyContent: "center"
-        },
-        children: "⬢"
+      /* @__PURE__ */ jsxDEV("span", {
+        style: {
+          fontSize: size === "md" ? "0.9rem" : "0.8rem",
+          height: "0.6em",
+          width: "0.6em",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center"
+        },
+        children: "⬢"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV("span", {
+        children: domain
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/devtools/browser/components/Chip.tsx
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+function Chip({
+  color,
+  borderColor,
+  fontSize = "8px",
+  padding = "1px 4px",
+  children,
+  style
+}) {
+  return /* @__PURE__ */ jsxDEV2("span", {
+    style: {
+      color,
+      fontSize,
+      background: "#0f172a",
+      border: `1px solid ${borderColor}`,
+      padding,
+      borderRadius: "3px",
+      flexShrink: 0,
+      whiteSpace: "nowrap",
+      ...style
+    },
+    children
+  }, undefined, false, undefined, this);
+}
+
+// src/devtools/browser/components/HandlerChips.tsx
+import { jsxDEV as jsxDEV3, Fragment } from "react/jsx-dev-runtime";
+function getExternalLabel(hop) {
+  if (hop.handlerType !== "external")
+    return null;
+  return hop.handlerClient != null ? `${hop.transport ?? "ext"} → ${hop.handlerClient.envId}` : `→ ${hop.transport ?? "ext"}`;
+}
+function HandlerChips({ entry, size }) {
+  const firstHop = entry.meta.routing[0];
+  const localEnvId = firstHop != null ? firstHop.runtime.envId : null;
+  const externalLabel = firstHop != null ? getExternalLabel(firstHop) : null;
+  const fontSize = size === "md" ? "1em" : "0.8em";
+  const padding = size === "md" ? "1px 5px" : "1px 4px";
+  const firstHopIsLocal = firstHop != null && firstHop.handlerType === "local";
+  return /* @__PURE__ */ jsxDEV3(Fragment, {
+    children: [
+      localEnvId != null && (firstHopIsLocal || externalLabel == null) && /* @__PURE__ */ jsxDEV3(Chip, {
+        color: DEVTOOL_COLOR_HANDLER_LOCAL_TEXT,
+        borderColor: DEVTOOL_COLOR_HANDLER_LOCAL_BORDER,
+        fontSize,
+        padding,
+        children: "local"
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV("span", {
-        children: domain
+      externalLabel != null && /* @__PURE__ */ jsxDEV3(Chip, {
+        color: DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT,
+        borderColor: DEVTOOL_COLOR_HANDLER_EXTERNAL_BORDER,
+        fontSize,
+        padding,
+        children: externalLabel
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -291,14 +2166,14 @@ function formatTimestamp(startTime) {
 }
 
 // src/devtools/browser/components/RunningTimer.tsx
-import { jsxDEV as jsxDEV2, Fragment } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV4, Fragment as Fragment2 } from "react/jsx-dev-runtime";
 function RunningTimer({ startTime }) {
   const [elapsed, setElapsed] = useState(() => Date.now() - startTime);
   useEffect(() => {
     const interval = setInterval(() => setElapsed(Date.now() - startTime), 100);
     return () => clearInterval(interval);
   }, [startTime]);
-  return /* @__PURE__ */ jsxDEV2(Fragment, {
+  return /* @__PURE__ */ jsxDEV4(Fragment2, {
     children: [
       elapsed,
       "ms"
@@ -307,17 +2182,17 @@ function RunningTimer({ startTime }) {
 }
 function DurationDisplay({ entry }) {
   const d = formatDuration(entry);
-  return /* @__PURE__ */ jsxDEV2(Fragment, {
-    children: d ?? /* @__PURE__ */ jsxDEV2(RunningTimer, {
+  return /* @__PURE__ */ jsxDEV4(Fragment2, {
+    children: d ?? /* @__PURE__ */ jsxDEV4(RunningTimer, {
       startTime: entry.startTime
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
 
 // src/devtools/browser/components/SectionLabel.tsx
-import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
 function SectionLabel({ label, color = "#60a5fa" }) {
-  return /* @__PURE__ */ jsxDEV3("div", {
+  return /* @__PURE__ */ jsxDEV5("div", {
     style: {
       color,
       fontSize: "10px",
@@ -330,7 +2205,24 @@ function SectionLabel({ label, color = "#60a5fa" }) {
 }
 
 // src/devtools/browser/components/CallStackSection.tsx
-import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
+function getCalledLabel(entry) {
+  const firstHop = entry.meta.routing[0];
+  if (firstHop == null)
+    return "↳ call";
+  if (firstHop.handlerType === "local")
+    return "↳ local";
+  const label = getExternalLabel(firstHop);
+  return label != null ? `↳ ${label}` : "↳ call";
+}
+function getCalledColor(entry) {
+  const firstHop = entry.meta.routing[0];
+  if (firstHop == null)
+    return "#a78bfa";
+  if (firstHop.handlerType === "local")
+    return DEVTOOL_COLOR_HANDLER_LOCAL_TEXT;
+  return DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT;
+}
 function CallStackLink({
   entry,
   entryRole,
@@ -339,60 +2231,65 @@ function CallStackLink({
 }) {
   const color = STATUS_COLOR[entry.status];
   const symbol = STATUS_SYMBOL[entry.status];
-  return /* @__PURE__ */ jsxDEV4("div", {
+  const labelColor = entryRole === "caller" ? "#94a3b8" : getCalledColor(entry);
+  const label = entryRole === "caller" ? "↑ from" : getCalledLabel(entry);
+  return /* @__PURE__ */ jsxDEV6("div", {
     onClick,
     style: {
       background: isFocused ? "#1e2e45" : "#1e293b",
       borderRadius: "4px",
       borderLeft: isFocused ? "2px solid #a78bfa" : "2px solid transparent",
       padding: isFocused ? "5px 8px 5px 6px" : "5px 8px",
-      display: "flex",
+      display: "grid",
+      gridTemplateColumns: "30% 1fr 30%",
       alignItems: "center",
-      gap: "8px",
+      columnGap: "8px",
       cursor: "pointer"
     },
     children: [
-      /* @__PURE__ */ jsxDEV4("span", {
+      /* @__PURE__ */ jsxDEV6("span", {
         style: {
-          color: entryRole === "caller" ? "#94a3b8" : "#a78bfa",
+          color: labelColor,
           fontSize: "9px",
-          flexShrink: 0,
-          minWidth: "34px",
-          fontFamily: "inherit"
+          whiteSpace: "nowrap",
+          overflow: "hidden",
+          textOverflow: "ellipsis"
         },
-        children: entryRole === "caller" ? "↑ from" : "↓ call"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV4("span", {
-        style: { color, fontSize: "10px", flexShrink: 0 },
-        children: symbol
+        children: label
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV4("span", {
+      /* @__PURE__ */ jsxDEV6("span", {
         style: {
-          color: "#cbd5e1",
-          fontSize: "11px",
-          flex: 1,
-          overflow: "hidden",
-          textOverflow: "ellipsis",
-          whiteSpace: "nowrap",
-          gap: "0.5em",
           display: "flex",
           alignItems: "center",
-          justifyContent: "center"
+          justifyContent: "center",
+          gap: "5px",
+          overflow: "hidden"
         },
         children: [
-          /* @__PURE__ */ jsxDEV4("span", {
+          /* @__PURE__ */ jsxDEV6("span", {
+            style: { color, fontSize: "10px", flexShrink: 0 },
+            children: symbol
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV6("span", {
+            style: {
+              color: "#cbd5e1",
+              fontSize: "11px",
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+              whiteSpace: "nowrap"
+            },
             children: entry.actionId
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV4(DomainChip, {
+          /* @__PURE__ */ jsxDEV6(DomainChip, {
             domain: entry.domain,
             allDomains: entry.allDomains,
             size: "sm"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV4("span", {
-        style: { color: "#475569", fontSize: "10px", flexShrink: 0 },
-        children: /* @__PURE__ */ jsxDEV4(DurationDisplay, {
+      /* @__PURE__ */ jsxDEV6("span", {
+        style: { color: "#475569", fontSize: "10px", textAlign: "right" },
+        children: /* @__PURE__ */ jsxDEV6(DurationDisplay, {
           entry
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this)
@@ -408,22 +2305,22 @@ function CallStackSection({
 }) {
   if (parent == null && childEntries.length === 0)
     return null;
-  return /* @__PURE__ */ jsxDEV4("div", {
+  return /* @__PURE__ */ jsxDEV6("div", {
     children: [
-      /* @__PURE__ */ jsxDEV4(SectionLabel, {
+      /* @__PURE__ */ jsxDEV6(SectionLabel, {
         label: "Call Stack",
         color: "#a78bfa"
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV4("div", {
+      /* @__PURE__ */ jsxDEV6("div", {
         style: { display: "flex", flexDirection: "column", gap: "2px" },
         children: [
-          parent != null && /* @__PURE__ */ jsxDEV4(CallStackLink, {
+          parent != null && /* @__PURE__ */ jsxDEV6(CallStackLink, {
             entry: parent,
             entryRole: "caller",
             isFocused: false,
             onClick: () => onSelectParent(parent.cuid)
           }, undefined, false, undefined, this),
-          childEntries.map((child) => /* @__PURE__ */ jsxDEV4(CallStackLink, {
+          childEntries.map((child) => /* @__PURE__ */ jsxDEV6(CallStackLink, {
             entry: child,
             entryRole: "called",
             isFocused: focusedChildCuid === child.cuid,
@@ -435,9 +2332,33 @@ function CallStackSection({
   }, undefined, true, undefined, this);
 }
 
+// src/devtools/browser/components/ChildDispatchChips.tsx
+import { jsxDEV as jsxDEV7, Fragment as Fragment3 } from "react/jsx-dev-runtime";
+function ChildDispatchChips({
+  labels,
+  size = "sm"
+}) {
+  if (labels == null || labels.length === 0)
+    return null;
+  const fontSize = size === "md" ? "1em" : "0.8em";
+  const padding = size === "md" ? "1px 4px" : "1px 3px";
+  return /* @__PURE__ */ jsxDEV7(Fragment3, {
+    children: labels.map((label) => /* @__PURE__ */ jsxDEV7(Chip, {
+      color: DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT,
+      borderColor: DEVTOOL_COLOR_HANDLER_EXTERNAL_BORDER,
+      fontSize,
+      padding,
+      children: [
+        "↳ ",
+        label
+      ]
+    }, label, true, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
 // src/devtools/browser/components/DetailSection.tsx
 import { useState as useState2 } from "react";
-import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
 var COMPACT_CHAR_LIMIT = 120;
 function DetailSection({
   label,
@@ -449,9 +2370,9 @@ function DetailSection({
   const compactJson = safeStringify(value, 0);
   const canExpand = fullJson !== compactJson || compactJson.length > COMPACT_CHAR_LIMIT;
   const compactDisplay = compactJson.length > COMPACT_CHAR_LIMIT ? `${compactJson.slice(0, COMPACT_CHAR_LIMIT)}…` : compactJson;
-  return /* @__PURE__ */ jsxDEV5("div", {
+  return /* @__PURE__ */ jsxDEV8("div", {
     children: [
-      /* @__PURE__ */ jsxDEV5("div", {
+      /* @__PURE__ */ jsxDEV8("div", {
         style: {
           display: "flex",
           alignItems: "center",
@@ -459,7 +2380,7 @@ function DetailSection({
           marginBottom: "3px"
         },
         children: [
-          /* @__PURE__ */ jsxDEV5("div", {
+          /* @__PURE__ */ jsxDEV8("div", {
             style: {
               color,
               fontSize: "10px",
@@ -468,13 +2389,13 @@ function DetailSection({
             },
             children: label
           }, undefined, false, undefined, this),
-          canExpand && /* @__PURE__ */ jsxDEV5("span", {
+          canExpand && /* @__PURE__ */ jsxDEV8("span", {
             style: { color: "#334155", fontSize: "11px" },
             children: expanded ? "▾" : "▸"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      expanded ? /* @__PURE__ */ jsxDEV5("div", {
+      expanded ? /* @__PURE__ */ jsxDEV8("div", {
         onClick: canExpand ? () => setExpanded(false) : undefined,
         style: {
           margin: 0,
@@ -490,7 +2411,7 @@ function DetailSection({
           cursor: canExpand ? "pointer" : "default"
         },
         children: fullJson
-      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV5("div", {
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV8("div", {
         onClick: canExpand ? () => setExpanded(true) : undefined,
         style: {
           padding: "5px 8px",
@@ -510,87 +2431,21 @@ function DetailSection({
   }, undefined, true, undefined, this);
 }
 
-// src/devtools/core/devtools_colors.ts
-var DEVTOOL_COLOR_HANDLER_LOCAL_TEXT = "#34bb89";
-var DEVTOOL_COLOR_HANDLER_LOCAL_BORDER = "#144427";
-var DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT = "#cfa12a";
-var DEVTOOL_COLOR_HANDLER_EXTERNAL_BORDER = "#723917";
-
-// src/devtools/browser/components/Chip.tsx
-import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
-function Chip({
-  color,
-  borderColor,
-  fontSize = "8px",
-  padding = "1px 4px",
-  children,
-  style
-}) {
-  return /* @__PURE__ */ jsxDEV6("span", {
-    style: {
-      color,
-      fontSize,
-      background: "#0f172a",
-      border: `1px solid ${borderColor}`,
-      padding,
-      borderRadius: "3px",
-      flexShrink: 0,
-      whiteSpace: "nowrap",
-      ...style
-    },
-    children
-  }, undefined, false, undefined, this);
-}
-
-// src/devtools/browser/components/HandlerChips.tsx
-import { jsxDEV as jsxDEV7, Fragment as Fragment2 } from "react/jsx-dev-runtime";
-function getExternalLabel(hop) {
-  if (hop.handlerType !== "external")
-    return null;
-  return hop.handlerClient != null ? `${hop.transport ?? "ext"} → ${hop.handlerClient.envId}` : `→ ${hop.transport ?? "ext"}`;
-}
-function HandlerChips({ entry, size }) {
-  const firstHop = entry.meta.routing[0];
-  const localEnvId = firstHop != null ? firstHop.runtime.envId : null;
-  const externalLabel = firstHop != null ? getExternalLabel(firstHop) : null;
-  const fontSize = size === "md" ? "1em" : "0.8em";
-  const padding = size === "md" ? "1px 5px" : "1px 4px";
-  const firstHopIsLocal = firstHop != null && firstHop.handlerType === "local";
-  return /* @__PURE__ */ jsxDEV7(Fragment2, {
-    children: [
-      localEnvId != null && (firstHopIsLocal || externalLabel == null) && /* @__PURE__ */ jsxDEV7(Chip, {
-        color: DEVTOOL_COLOR_HANDLER_LOCAL_TEXT,
-        borderColor: DEVTOOL_COLOR_HANDLER_LOCAL_BORDER,
-        fontSize,
-        padding,
-        children: "local"
-      }, undefined, false, undefined, this),
-      externalLabel != null && /* @__PURE__ */ jsxDEV7(Chip, {
-        color: DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT,
-        borderColor: DEVTOOL_COLOR_HANDLER_EXTERNAL_BORDER,
-        fontSize,
-        padding,
-        children: externalLabel
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-
 // src/devtools/browser/components/MetaSection.tsx
 import { useState as useState3 } from "react";
-import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
 function MetaChip({ label, value }) {
-  return /* @__PURE__ */ jsxDEV8("span", {
+  return /* @__PURE__ */ jsxDEV9("span", {
     style: { whiteSpace: "nowrap" },
     children: [
-      /* @__PURE__ */ jsxDEV8("span", {
+      /* @__PURE__ */ jsxDEV9("span", {
         style: { color: "#475569" },
         children: [
           label,
           " "
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV8("span", {
+      /* @__PURE__ */ jsxDEV9("span", {
         style: { color: "#cbd5e1" },
         children: value
       }, undefined, false, undefined, this)
@@ -606,9 +2461,9 @@ function MetaSection({ entry }) {
     ...meta.originClient.perId != null ? [{ label: "perId", value: meta.originClient.perId }] : [],
     ...meta.originClient.insId != null ? [{ label: "insId", value: meta.originClient.insId }] : []
   ];
-  return /* @__PURE__ */ jsxDEV8("div", {
+  return /* @__PURE__ */ jsxDEV9("div", {
     children: [
-      /* @__PURE__ */ jsxDEV8("div", {
+      /* @__PURE__ */ jsxDEV9("div", {
         style: {
           display: "flex",
           alignItems: "center",
@@ -616,7 +2471,7 @@ function MetaSection({ entry }) {
           marginBottom: "3px"
         },
         children: [
-          /* @__PURE__ */ jsxDEV8("div", {
+          /* @__PURE__ */ jsxDEV9("div", {
             style: {
               color: "#60a5fa",
               fontSize: "10px",
@@ -625,16 +2480,16 @@ function MetaSection({ entry }) {
             },
             children: "Meta"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV8("span", {
+          /* @__PURE__ */ jsxDEV9("span", {
             style: { color: "#334155", fontSize: "11px" },
             children: expanded ? "▾" : "▸"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      expanded ? /* @__PURE__ */ jsxDEV8("div", {
+      expanded ? /* @__PURE__ */ jsxDEV9("div", {
         onClick: () => setExpanded(false),
         style: { background: "#1e293b", borderRadius: "4px", overflow: "hidden", cursor: "pointer" },
-        children: expandedRows.map(({ label, value }, i) => /* @__PURE__ */ jsxDEV8("div", {
+        children: expandedRows.map(({ label, value }, i) => /* @__PURE__ */ jsxDEV9("div", {
           style: {
             display: "grid",
             gridTemplateColumns: "52px 1fr",
@@ -644,17 +2499,17 @@ function MetaSection({ entry }) {
             alignItems: "start"
           },
           children: [
-            /* @__PURE__ */ jsxDEV8("span", {
+            /* @__PURE__ */ jsxDEV9("span", {
               style: { textAlign: "left", color: "#475569", fontSize: "10px", paddingTop: "1px" },
               children: label
             }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsxDEV8("span", {
+            /* @__PURE__ */ jsxDEV9("span", {
               style: { textAlign: "left", color: "#cbd5e1", fontSize: "11px", wordBreak: "break-all" },
               children: value
             }, undefined, false, undefined, this)
           ]
         }, label, true, undefined, this))
-      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV8("div", {
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV9("div", {
         onClick: () => setExpanded(true),
         style: {
           background: "#1e293b",
@@ -668,19 +2523,19 @@ function MetaSection({ entry }) {
           cursor: "pointer"
         },
         children: [
-          /* @__PURE__ */ jsxDEV8(MetaChip, {
+          /* @__PURE__ */ jsxDEV9(MetaChip, {
             label: "cuid",
             value: `…${cuid.slice(-8)}`
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV8(MetaChip, {
+          /* @__PURE__ */ jsxDEV9(MetaChip, {
             label: "origin",
             value: meta.originClient.envId
           }, undefined, false, undefined, this),
-          meta.originClient.perId != null && /* @__PURE__ */ jsxDEV8(MetaChip, {
+          meta.originClient.perId != null && /* @__PURE__ */ jsxDEV9(MetaChip, {
             label: "perId",
             value: meta.originClient.perId.length > 10 ? `${meta.originClient.perId.slice(0, 10)}…` : meta.originClient.perId
           }, undefined, false, undefined, this),
-          meta.originClient.insId != null && /* @__PURE__ */ jsxDEV8(MetaChip, {
+          meta.originClient.insId != null && /* @__PURE__ */ jsxDEV9(MetaChip, {
             label: "insId",
             value: meta.originClient.insId.length > 10 ? `${meta.originClient.insId.slice(0, 10)}…` : meta.originClient.insId
           }, undefined, false, undefined, this)
@@ -691,7 +2546,7 @@ function MetaSection({ entry }) {
 }
 
 // src/devtools/browser/components/RoutingSection.tsx
-import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV10 } from "react/jsx-dev-runtime";
 function RoutingSection({
   entry,
   minHopCount = 0
@@ -701,12 +2556,12 @@ function RoutingSection({
   const phantomCount = Math.max(0, minHopCount - hopCount);
   if (hopCount === 0 && phantomCount === 0)
     return null;
-  return /* @__PURE__ */ jsxDEV9("div", {
+  return /* @__PURE__ */ jsxDEV10("div", {
     children: [
-      /* @__PURE__ */ jsxDEV9(SectionLabel, {
+      /* @__PURE__ */ jsxDEV10(SectionLabel, {
         label: hopCount > 0 ? `Routing · ${hopCount} hop${hopCount !== 1 ? "s" : ""}` : "Routing"
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV9("div", {
+      /* @__PURE__ */ jsxDEV10("div", {
         style: { display: "flex", flexDirection: "column", gap: "2px" },
         children: [
           meta.routing.map((hop, i) => {
@@ -715,7 +2570,7 @@ function RoutingSection({
             const badgeColor = isLocal ? "#34d399" : "#fbbf24";
             const badgeText = isLocal ? "● exec" : `→ ${hop.transport ?? "ext"}`;
             const runtimeTitle = [hop.runtime.perId, hop.runtime.insId].filter(Boolean).join(" · ") || undefined;
-            return /* @__PURE__ */ jsxDEV9("div", {
+            return /* @__PURE__ */ jsxDEV10("div", {
               style: {
                 background: "#1e293b",
                 borderRadius: "4px",
@@ -728,14 +2583,14 @@ function RoutingSection({
                 padding: "4px 8px"
               },
               children: [
-                /* @__PURE__ */ jsxDEV9("span", {
+                /* @__PURE__ */ jsxDEV10("span", {
                   style: { display: "flex", flexDirection: "row", alignItems: "center", gap: "10px" },
                   children: [
-                    /* @__PURE__ */ jsxDEV9("span", {
+                    /* @__PURE__ */ jsxDEV10("span", {
                       style: { color: "#334155", fontSize: "10px", width: "16px", textAlign: "right" },
                       children: i + 1
                     }, undefined, false, undefined, this),
-                    /* @__PURE__ */ jsxDEV9("span", {
+                    /* @__PURE__ */ jsxDEV10("span", {
                       title: runtimeTitle,
                       style: {
                         color: "#94a3b8",
@@ -749,11 +2604,11 @@ function RoutingSection({
                     }, undefined, false, undefined, this)
                   ]
                 }, undefined, true, undefined, this),
-                /* @__PURE__ */ jsxDEV9("span", {
+                /* @__PURE__ */ jsxDEV10("span", {
                   style: { color: badgeColor, fontSize: "10px", whiteSpace: "nowrap" },
                   children: badgeText
                 }, undefined, false, undefined, this),
-                /* @__PURE__ */ jsxDEV9("span", {
+                /* @__PURE__ */ jsxDEV10("span", {
                   style: {
                     display: "flex",
                     alignItems: "center",
@@ -762,7 +2617,7 @@ function RoutingSection({
                     overflow: "hidden"
                   },
                   children: [
-                    /* @__PURE__ */ jsxDEV9("span", {
+                    /* @__PURE__ */ jsxDEV10("span", {
                       style: {
                         color: "#475569",
                         fontSize: "10px",
@@ -772,7 +2627,7 @@ function RoutingSection({
                       },
                       children: hop.handlerClient != null ? `↳ ${hop.handlerClient.envId}` : ""
                     }, undefined, false, undefined, this),
-                    /* @__PURE__ */ jsxDEV9("span", {
+                    /* @__PURE__ */ jsxDEV10("span", {
                       style: { color: "#334155", fontSize: "10px", flexShrink: 0, marginLeft: "auto" },
                       children: [
                         "+",
@@ -785,7 +2640,7 @@ function RoutingSection({
               ]
             }, `${hop.time}-${hop.runtime.envId}`, true, undefined, this);
           }),
-          Array.from({ length: phantomCount }, (_, i) => `routing-phantom-${hopCount + i}`).map((key) => /* @__PURE__ */ jsxDEV9("div", {
+          Array.from({ length: phantomCount }, (_, i) => `routing-phantom-${hopCount + i}`).map((key) => /* @__PURE__ */ jsxDEV10("div", {
             "aria-hidden": "true",
             style: {
               visibility: "hidden",
@@ -798,24 +2653,24 @@ function RoutingSection({
               padding: "4px 8px"
             },
             children: [
-              /* @__PURE__ */ jsxDEV9("span", {
+              /* @__PURE__ */ jsxDEV10("span", {
                 style: { display: "flex", flexDirection: "row", alignItems: "center", gap: "10px" },
                 children: [
-                  /* @__PURE__ */ jsxDEV9("span", {
+                  /* @__PURE__ */ jsxDEV10("span", {
                     style: { fontSize: "10px", width: "16px" },
                     children: "0"
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV9("span", {
+                  /* @__PURE__ */ jsxDEV10("span", {
                     style: { fontSize: "11px" },
                     children: "placeholder"
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              /* @__PURE__ */ jsxDEV9("span", {
+              /* @__PURE__ */ jsxDEV10("span", {
                 style: { fontSize: "10px" },
                 children: "placeholder"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV9("span", {}, undefined, false, undefined, this)
+              /* @__PURE__ */ jsxDEV10("span", {}, undefined, false, undefined, this)
             ]
           }, key, true, undefined, this))
         ]
@@ -825,8 +2680,70 @@ function RoutingSection({
 }
 
 // src/devtools/browser/components/StackTraceSection.tsx
-import { useState as useState4 } from "react";
-import { jsxDEV as jsxDEV10 } from "react/jsx-dev-runtime";
+import { useEffect as useEffect2, useState as useState4 } from "react";
+
+// ../../node_modules/.bun/source-map-js@1.2.1/node_modules/source-map-js/source-map.js
+var $SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
+var $SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
+var $SourceNode = require_source_node().SourceNode;
+
+// src/devtools/browser/components/sourceMapResolver.ts
+var consumerCache = new Map;
+async function loadConsumer(fileUrl) {
+  try {
+    if (!fileUrl.startsWith("http://") && !fileUrl.startsWith("https://"))
+      return null;
+    const resp = await fetch(fileUrl);
+    if (!resp.ok)
+      return null;
+    const text = await resp.text();
+    const match = text.match(/\/\/[#@] sourceMappingURL=(\S+)/);
+    if (match == null)
+      return null;
+    const mapRef = match[1];
+    let mapJson;
+    if (mapRef.startsWith("data:")) {
+      const commaIdx = mapRef.indexOf(",");
+      if (commaIdx === -1)
+        return null;
+      const header = mapRef.slice(5, commaIdx);
+      const payload = mapRef.slice(commaIdx + 1);
+      mapJson = header.includes("base64") ? atob(payload) : decodeURIComponent(payload);
+    } else {
+      const mapUrl = new URL(mapRef, fileUrl).href;
+      const mapResp = await fetch(mapUrl);
+      if (!mapResp.ok)
+        return null;
+      mapJson = await mapResp.text();
+    }
+    return new $SourceMapConsumer(JSON.parse(mapJson));
+  } catch {
+    return null;
+  }
+}
+function getConsumer(fileUrl) {
+  const key = fileUrl.split("?")[0] ?? fileUrl;
+  if (!consumerCache.has(key)) {
+    consumerCache.set(key, loadConsumer(fileUrl));
+  }
+  return consumerCache.get(key);
+}
+async function resolveCompiledPosition(fileUrl, line, col) {
+  try {
+    const consumer = await getConsumer(fileUrl);
+    if (consumer == null)
+      return null;
+    const pos = consumer.originalPositionFor({ line, column: col });
+    if (pos.source == null || pos.line == null)
+      return null;
+    return { file: pos.source, line: pos.line, col: pos.column ?? 0 };
+  } catch {
+    return null;
+  }
+}
+
+// src/devtools/browser/components/StackTraceSection.tsx
+import { jsxDEV as jsxDEV11 } from "react/jsx-dev-runtime";
 var INTERNAL_PATTERNS = [
   "/nice-action/",
   "@nice-code/action",
@@ -846,16 +2763,39 @@ function parseStackFrames(stack) {
     const matchFn = raw.match(/^at (.+?) \((.+):(\d+):(\d+)\)$/);
     if (matchFn != null) {
       const file = matchFn[2];
-      return { fn: matchFn[1], file, raw, isInternal: isInternalFrame(file) };
+      return {
+        fn: matchFn[1],
+        file,
+        line: parseInt(matchFn[3], 10),
+        col: parseInt(matchFn[4], 10),
+        raw,
+        isInternal: isInternalFrame(file)
+      };
     }
     const matchUrl = raw.match(/^at (.+):(\d+):(\d+)$/);
     if (matchUrl != null) {
       const file = matchUrl[1];
-      return { file, raw, isInternal: isInternalFrame(file) };
+      return {
+        file,
+        line: parseInt(matchUrl[2], 10),
+        col: parseInt(matchUrl[3], 10),
+        raw,
+        isInternal: isInternalFrame(file)
+      };
     }
     return { raw, isInternal: true };
   }).filter((f) => f != null);
 }
+async function resolveSourceMapPositions(frames) {
+  return Promise.all(frames.map(async (frame) => {
+    if (frame.isInternal || frame.file == null || frame.line == null)
+      return frame;
+    const resolved = await resolveCompiledPosition(frame.file, frame.line, frame.col ?? 0);
+    if (resolved == null)
+      return frame;
+    return { ...frame, file: resolved.file, line: resolved.line, col: resolved.col };
+  }));
+}
 function formatFrameFile(file) {
   if (file == null)
     return "?";
@@ -877,17 +2817,32 @@ function StackTraceSection({
   color = "#60a5fa"
 }) {
   const [showAll, setShowAll] = useState4(false);
+  const [resolvedFrames, setResolvedFrames] = useState4(null);
+  useEffect2(() => {
+    if (stack == null)
+      return;
+    setResolvedFrames(null);
+    const parsed = parseStackFrames(stack);
+    let cancelled = false;
+    resolveSourceMapPositions(parsed).then((frames) => {
+      if (!cancelled)
+        setResolvedFrames(frames);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [stack]);
   if (stack == null)
     return null;
-  const allFrames = parseStackFrames(stack);
+  const allFrames = resolvedFrames ?? parseStackFrames(stack);
   const userFrames = allFrames.filter((f) => !f.isInternal);
   const hasInternalFrames = allFrames.length > userFrames.length;
   const displayFrames = showAll ? allFrames : userFrames;
   if (allFrames.length === 0)
     return null;
-  return /* @__PURE__ */ jsxDEV10("div", {
+  return /* @__PURE__ */ jsxDEV11("div", {
     children: [
-      /* @__PURE__ */ jsxDEV10("div", {
+      /* @__PURE__ */ jsxDEV11("div", {
         style: {
           display: "flex",
           alignItems: "center",
@@ -895,17 +2850,17 @@ function StackTraceSection({
           marginBottom: "3px"
         },
         children: [
-          /* @__PURE__ */ jsxDEV10(SectionLabel, {
+          /* @__PURE__ */ jsxDEV11(SectionLabel, {
             label,
             color
           }, undefined, false, undefined, this),
-          hasInternalFrames && /* @__PURE__ */ jsxDEV10("span", {
+          hasInternalFrames && /* @__PURE__ */ jsxDEV11("span", {
             style: { color: "#475569", fontSize: "9px" },
             children: !showAll ? "user only" : `all (${allFrames.length})`
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV10("div", {
+      /* @__PURE__ */ jsxDEV11("div", {
         onClick: () => setShowAll((s) => !s),
         style: {
           background: "#040a13",
@@ -914,7 +2869,7 @@ function StackTraceSection({
           overflow: "hidden",
           cursor: "pointer"
         },
-        children: displayFrames.length === 0 ? /* @__PURE__ */ jsxDEV10("div", {
+        children: displayFrames.length === 0 ? /* @__PURE__ */ jsxDEV11("div", {
           style: { padding: "6px 10px", color: "#64748b", fontSize: "10px", fontStyle: "italic" },
           children: "no user frames captured"
         }, undefined, false, undefined, this) : displayFrames.map((frame, idx) => {
@@ -924,7 +2879,7 @@ function StackTraceSection({
           const bareFilename = slashIdx >= 0 ? displayFile.slice(slashIdx + 1) : displayFile;
           const titleStr = frame.file != null ? frame.file : frame.raw;
           const isUser = !frame.isInternal;
-          return /* @__PURE__ */ jsxDEV10("div", {
+          return /* @__PURE__ */ jsxDEV11("div", {
             title: titleStr,
             style: {
               display: "flex",
@@ -934,7 +2889,7 @@ function StackTraceSection({
               borderBottom: idx < displayFrames.length - 1 ? "1px solid #0f172a" : undefined
             },
             children: [
-              /* @__PURE__ */ jsxDEV10("span", {
+              /* @__PURE__ */ jsxDEV11("span", {
                 style: {
                   color: isUser ? "#64748b" : "#2d3f53",
                   fontSize: "10px",
@@ -945,12 +2900,12 @@ function StackTraceSection({
                 },
                 children: idx + 1
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV10("div", {
+              /* @__PURE__ */ jsxDEV11("div", {
                 style: { display: "flex", flexDirection: "column", gap: "0.15em", lineHeight: 1.2 },
                 children: [
-                  /* @__PURE__ */ jsxDEV10("div", {
+                  /* @__PURE__ */ jsxDEV11("div", {
                     style: { display: "flex", alignItems: "center" },
-                    children: /* @__PURE__ */ jsxDEV10("span", {
+                    children: /* @__PURE__ */ jsxDEV11("span", {
                       style: {
                         color: isUser ? "#e2e8f0" : "#50698b",
                         fontSize: "12px",
@@ -962,10 +2917,10 @@ function StackTraceSection({
                       children: frame.fn ?? "(anonymous)"
                     }, undefined, false, undefined, this)
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV10("div", {
+                  /* @__PURE__ */ jsxDEV11("div", {
                     style: { display: "flex", alignItems: "baseline", overflow: "hidden" },
                     children: [
-                      folderPrefix !== "" && /* @__PURE__ */ jsxDEV10("span", {
+                      folderPrefix !== "" && /* @__PURE__ */ jsxDEV11("span", {
                         style: {
                           color: isUser ? "#596b83" : "#2d3f53",
                           fontSize: "10px",
@@ -977,7 +2932,7 @@ function StackTraceSection({
                         },
                         children: folderPrefix
                       }, undefined, false, undefined, this),
-                      /* @__PURE__ */ jsxDEV10("span", {
+                      /* @__PURE__ */ jsxDEV11("span", {
                         style: {
                           color: isUser ? "#8a9ebb" : "#425979",
                           fontSize: "10px",
@@ -985,13 +2940,26 @@ function StackTraceSection({
                           flexShrink: 0
                         },
                         children: bareFilename
-                      }, undefined, false, undefined, this)
+                      }, undefined, false, undefined, this),
+                      frame.line != null && /* @__PURE__ */ jsxDEV11("span", {
+                        style: {
+                          color: isUser ? "#4a7fa8" : "#2d4a63",
+                          fontSize: "10px",
+                          whiteSpace: "nowrap",
+                          flexShrink: 0,
+                          fontVariantNumeric: "tabular-nums"
+                        },
+                        children: [
+                          ":",
+                          frame.line
+                        ]
+                      }, undefined, true, undefined, this)
                     ]
                   }, undefined, true, undefined, this)
                 ]
               }, undefined, true, undefined, this)
             ]
-          }, `${frame.fn ?? "anon"}@${frame.file ?? "unknown"}`, true, undefined, this);
+          }, frame.raw, true, undefined, this);
         })
       }, undefined, false, undefined, this)
     ]
@@ -999,7 +2967,7 @@ function StackTraceSection({
 }
 
 // src/devtools/browser/components/ActionDetailPanel.tsx
-import { jsxDEV as jsxDEV11, Fragment as Fragment3 } from "react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV12, Fragment as Fragment4 } from "react/jsx-dev-runtime";
 function DetailHeader({
   entry,
   isActive,
@@ -1009,7 +2977,7 @@ function DetailHeader({
   const color = STATUS_COLOR[entry.status];
   const symbol = STATUS_SYMBOL[entry.status];
   const timestamp = formatTimestamp(entry.startTime);
-  return /* @__PURE__ */ jsxDEV11("div", {
+  return /* @__PURE__ */ jsxDEV12("div", {
     onClick: !isActive ? onClick : undefined,
     style: {
       padding: "10px 12px",
@@ -1023,7 +2991,7 @@ function DetailHeader({
       cursor: isActive ? "default" : "pointer"
     },
     children: [
-      /* @__PURE__ */ jsxDEV11("span", {
+      /* @__PURE__ */ jsxDEV12("span", {
         style: {
           color,
           fontSize: "15px",
@@ -1033,17 +3001,17 @@ function DetailHeader({
         },
         children: symbol
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV11("div", {
+      /* @__PURE__ */ jsxDEV12("div", {
         style: { flex: 1, minWidth: 0, display: "flex", flexDirection: "column", gap: "0.5em" },
         children: [
-          /* @__PURE__ */ jsxDEV11("div", {
+          /* @__PURE__ */ jsxDEV12("div", {
             style: { display: "flex", alignItems: "center", minWidth: 0, gap: "0.4em" },
             children: [
-              /* @__PURE__ */ jsxDEV11("span", {
+              /* @__PURE__ */ jsxDEV12("span", {
                 style: { fontSize: "1.2em" },
                 children: "⚡"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV11("span", {
+              /* @__PURE__ */ jsxDEV12("span", {
                 style: {
                   color: "#f1f5f9",
                   fontSize: "1.2em",
@@ -1056,14 +3024,14 @@ function DetailHeader({
                 },
                 children: entry.actionId
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV11(DomainChip, {
+              /* @__PURE__ */ jsxDEV12(DomainChip, {
                 domain: entry.domain,
                 allDomains: entry.allDomains,
                 size: "md"
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          /* @__PURE__ */ jsxDEV11("div", {
+          /* @__PURE__ */ jsxDEV12("div", {
             style: {
               display: "flex",
               alignItems: "center",
@@ -1071,7 +3039,7 @@ function DetailHeader({
               gap: "8px"
             },
             children: [
-              /* @__PURE__ */ jsxDEV11("div", {
+              /* @__PURE__ */ jsxDEV12("div", {
                 style: {
                   display: "flex",
                   alignItems: "center",
@@ -1079,21 +3047,27 @@ function DetailHeader({
                   minWidth: 0,
                   overflow: "hidden"
                 },
-                children: /* @__PURE__ */ jsxDEV11(HandlerChips, {
-                  entry,
-                  size: "md"
-                }, undefined, false, undefined, this)
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV11("div", {
+                children: [
+                  /* @__PURE__ */ jsxDEV12(HandlerChips, {
+                    entry,
+                    size: "md"
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV12(ChildDispatchChips, {
+                    labels: childExternalLabels,
+                    size: "md"
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              /* @__PURE__ */ jsxDEV12("div", {
                 style: { display: "flex", alignItems: "center", gap: "8px", flexShrink: 0 },
                 children: [
-                  /* @__PURE__ */ jsxDEV11("span", {
+                  /* @__PURE__ */ jsxDEV12("span", {
                     style: { color: "#334155", fontSize: "10px", letterSpacing: "0.02em" },
                     children: timestamp
                   }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV11("span", {
+                  /* @__PURE__ */ jsxDEV12("span", {
                     style: { color, fontSize: "12px", fontWeight: "500" },
-                    children: /* @__PURE__ */ jsxDEV11(DurationDisplay, {
+                    children: /* @__PURE__ */ jsxDEV12(DurationDisplay, {
                       entry
                     }, undefined, false, undefined, this)
                   }, undefined, false, undefined, this)
@@ -1133,7 +3107,7 @@ function ActionDetailPanel({
   const handleFocusChild = (cuid) => {
     setFocusedChildCuid((prev) => prev === cuid ? null : cuid);
   };
-  return /* @__PURE__ */ jsxDEV11("div", {
+  return /* @__PURE__ */ jsxDEV12("div", {
     style: {
       flex: 1,
       display: "flex",
@@ -1143,13 +3117,13 @@ function ActionDetailPanel({
       background: "#0f172a"
     },
     children: [
-      /* @__PURE__ */ jsxDEV11(DetailHeader, {
+      /* @__PURE__ */ jsxDEV12(DetailHeader, {
         entry,
         isActive: focusedChildCuid === null,
         onClick: () => setFocusedChildCuid(null),
         childExternalLabels
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV11("div", {
+      /* @__PURE__ */ jsxDEV12("div", {
         style: {
           flex: 1,
           overflowY: "auto",
@@ -1160,63 +3134,63 @@ function ActionDetailPanel({
           gap: "8px"
         },
         children: [
-          /* @__PURE__ */ jsxDEV11(CallStackSection, {
+          /* @__PURE__ */ jsxDEV12(CallStackSection, {
             parent,
             childEntries,
             focusedChildCuid,
             onFocusChild: handleFocusChild,
             onSelectParent: onSelectEntry
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV11(MetaSection, {
+          /* @__PURE__ */ jsxDEV12(MetaSection, {
             entry: focusedEntry
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV11(RoutingSection, {
+          /* @__PURE__ */ jsxDEV12(RoutingSection, {
             entry: focusedEntry,
             minHopCount: maxRoutingHops
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV11(StackTraceSection, {
+          /* @__PURE__ */ jsxDEV12(StackTraceSection, {
             label: "Dispatch Site",
             stack: focusedEntry.callSite,
             color: "#94a3b8"
           }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV11(DetailSection, {
+          /* @__PURE__ */ jsxDEV12(DetailSection, {
             label: "Input",
             value: focusedEntry.input
           }, undefined, false, undefined, this),
-          focusedEntry.status === "success" && /* @__PURE__ */ jsxDEV11(DetailSection, {
+          focusedEntry.status === "success" && /* @__PURE__ */ jsxDEV12(DetailSection, {
             label: "Output",
             value: focusedEntry.output,
             color: "#4ade80"
           }, undefined, false, undefined, this),
-          focusedEntry.status === "failed" && /* @__PURE__ */ jsxDEV11(Fragment3, {
+          focusedEntry.status === "failed" && /* @__PURE__ */ jsxDEV12(Fragment4, {
             children: [
-              /* @__PURE__ */ jsxDEV11(DetailSection, {
+              /* @__PURE__ */ jsxDEV12(DetailSection, {
                 label: "Error",
                 value: focusedEntry.error,
                 color: "#f87171"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV11(StackTraceSection, {
+              /* @__PURE__ */ jsxDEV12(StackTraceSection, {
                 label: "Error Stack",
                 stack: focusedEntry.errorStack,
                 color: "#f87171"
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          focusedEntry.status === "aborted" && /* @__PURE__ */ jsxDEV11(Fragment3, {
+          focusedEntry.status === "aborted" && /* @__PURE__ */ jsxDEV12(Fragment4, {
             children: [
-              focusedEntry.abortReason != null && /* @__PURE__ */ jsxDEV11(DetailSection, {
+              focusedEntry.abortReason != null && /* @__PURE__ */ jsxDEV12(DetailSection, {
                 label: "Abort Reason",
                 value: focusedEntry.abortReason,
                 color: "#9ca3af"
               }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsxDEV11(StackTraceSection, {
+              /* @__PURE__ */ jsxDEV12(StackTraceSection, {
                 label: "Abort Stack",
                 stack: focusedEntry.errorStack,
                 color: "#9ca3af"
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          focusedEntry.progressUpdates.length > 0 && /* @__PURE__ */ jsxDEV11(DetailSection, {
+          focusedEntry.progressUpdates.length > 0 && /* @__PURE__ */ jsxDEV12(DetailSection, {
             label: `Progress (${focusedEntry.progressUpdates.length})`,
             value: focusedEntry.progressUpdates
           }, undefined, false, undefined, this)
@@ -1226,30 +3200,6 @@ function ActionDetailPanel({
   }, undefined, true, undefined, this);
 }
 
-// src/devtools/browser/components/ChildDispatchChips.tsx
-import { jsxDEV as jsxDEV12, Fragment as Fragment4 } from "react/jsx-dev-runtime";
-function ChildDispatchChips({
-  labels,
-  size = "sm"
-}) {
-  if (labels == null || labels.length === 0)
-    return null;
-  const fontSize = size === "md" ? "1em" : "0.8em";
-  const padding = size === "md" ? "1px 4px" : "1px 3px";
-  return /* @__PURE__ */ jsxDEV12(Fragment4, {
-    children: labels.map((label) => /* @__PURE__ */ jsxDEV12(Chip, {
-      color: DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT,
-      borderColor: DEVTOOL_COLOR_HANDLER_EXTERNAL_BORDER,
-      fontSize,
-      padding,
-      children: [
-        "↳ ",
-        label
-      ]
-    }, label, true, undefined, this))
-  }, undefined, false, undefined, this);
-}
-
 // src/devtools/browser/components/ActionEntryRow.tsx
 import { jsxDEV as jsxDEV13 } from "react/jsx-dev-runtime";
 function ActionEntryRow({
@@ -1702,7 +3652,7 @@ function NiceActionDevtools_Panel({
   const showDomainTooltip = useCallback((rect, allDomains) => setDomainTooltip({ rect, allDomains }), []);
   const hideDomainTooltip = useCallback(() => setDomainTooltip(null), []);
   const domainTooltipCtx = useMemo2(() => ({ show: showDomainTooltip, hide: hideDomainTooltip }), [showDomainTooltip, hideDomainTooltip]);
-  useEffect2(() => core.subscribe(setEntries), [core]);
+  useEffect3(() => core.subscribe(setEntries), [core]);
   const groups = useMemo2(() => {
     const byCuid = new Map(entries.map((e) => [e.cuid, e]));
     const roots = entries.filter((e) => e.status !== "running" && (e.parentCuid == null || !byCuid.has(e.parentCuid)));
@@ -1754,7 +3704,7 @@ function NiceActionDevtools_Panel({
   const dockedSize = isHorizDock ? dockedHeight : dockedWidth;
   const selectedEntry = selectedCuid != null ? entries.find((e) => e.cuid === selectedCuid) : null;
   const runningCount = entries.filter((e) => e.status === "running").length;
-  useEffect2(() => {
+  useEffect3(() => {
     const sides = ["top", "bottom", "left", "right"];
     const clearAll = () => {
       sides.forEach((s) => {
@@ -2021,7 +3971,7 @@ function ActionList({
     return result;
   }, [groups, expandedGroupCuids, selectedCuid]);
   const prevSelectedRef = useRef2(selectedCuid);
-  useEffect2(() => {
+  useEffect3(() => {
     if (selectedCuid === prevSelectedRef.current)
       return;
     prevSelectedRef.current = selectedCuid;