@industry-theme/backlogmd-kanban-panel 1.0.41 → 1.0.42

package/dist/panels.bundle.js

@@ -1132,7 +1132,7 @@ class KeyboardSensor {
     if (isKeyboardEvent(event)) {
       const {
         active,
-        context,
+        context: context2,
         options
       } = this.props;
       const {
@@ -1153,7 +1153,7 @@ class KeyboardSensor {
       }
       const {
         collisionRect
-      } = context.current;
+      } = context2.current;
       const currentCoordinates = collisionRect ? {
         x: collisionRect.left,
         y: collisionRect.top
@@ -1163,7 +1163,7 @@ class KeyboardSensor {
       }
       const newCoordinates = coordinateGetter(event, {
         active,
-        context: context.current,
+        context: context2.current,
         currentCoordinates
       });
       if (newCoordinates) {
@@ -1174,7 +1174,7 @@ class KeyboardSensor {
         };
         const {
           scrollableAncestors
-        } = context.current;
+        } = context2.current;
         for (const scrollContainer of scrollableAncestors) {
           const direction = event.code;
           const {
@@ -3026,7 +3026,7 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
     scrollableAncestorRects
   });
   const publicContext = useMemo(() => {
-    const context = {
+    const context2 = {
       active,
       activeNode,
       activeNodeRect,
@@ -3045,10 +3045,10 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
       measuringScheduled,
       windowRect
     };
-    return context;
+    return context2;
   }, [active, activeNode, activeNodeRect, activatorEvent, collisions, containerNodeRect, dragOverlay, draggableNodes, droppableContainers, droppableRects, over, measureDroppableContainers, scrollableAncestors, scrollableAncestorRects, measuringConfiguration, measuringScheduled, windowRect]);
   const internalContext = useMemo(() => {
-    const context = {
+    const context2 = {
       activatorEvent,
       activators,
       active,
@@ -3061,7 +3061,7 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
       over,
       measureDroppableContainers
     };
-    return context;
+    return context2;
   }, [activatorEvent, activators, active, activeNodeRect, dispatch, draggableDescribedById, draggableNodes, over, measureDroppableContainers]);
   return React2__default.createElement(DndMonitorContext.Provider, {
     value: registerMonitorListener
@@ -4057,11 +4057,11 @@ var getThemeContext$1 = () => {
 };
 var ThemeContextSingleton = getThemeContext$1();
 var useTheme = () => {
-  const context = useContext(ThemeContextSingleton);
-  if (!context) {
+  const context2 = useContext(ThemeContextSingleton);
+  if (!context2) {
     throw new Error("useTheme must be used within a ThemeProvider");
   }
-  return context;
+  return context2;
 };
 const PanelGroupContext$1 = createContext(null);
 PanelGroupContext$1.displayName = "PanelGroupContext";
@@ -4106,8 +4106,8 @@ function PanelWithForwardedRef$1({
   tagName: Type = "div",
   ...rest
 }) {
-  const context = useContext(PanelGroupContext$1);
-  if (context === null) {
+  const context2 = useContext(PanelGroupContext$1);
+  if (context2 === null) {
     throw Error(`Panel components must be rendered within a PanelGroup container`);
   }
   const {
@@ -4121,7 +4121,7 @@ function PanelWithForwardedRef$1({
     registerPanel,
     resizePanel: resizePanel2,
     unregisterPanel
-  } = context;
+  } = context2;
   const panelId = useUniqueId$1(idFromProps);
   const panelDataRef = useRef({
     callbacks: {
@@ -5486,7 +5486,7 @@ function PanelGroupWithForwardedRef$1({
       forceUpdate();
     }
   }, [forceUpdate]);
-  const context = useMemo(() => ({
+  const context2 = useMemo(() => ({
     collapsePanel,
     direction,
     dragState,
@@ -5513,7 +5513,7 @@ function PanelGroupWithForwardedRef$1({
     width: "100%"
   };
   return createElement(PanelGroupContext$1.Provider, {
-    value: context
+    value: context2
   }, createElement(Type, {
     ...rest,
     children: children2,
@@ -7981,6 +7981,724 @@ class PanelFileSystemAdapter {
     return path2.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\/+/g, "/");
   }
 }
+var _globalThis = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+var VERSION = "1.9.0";
+var re$1 = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function _makeCompatibilityCheck(ownVersion) {
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re$1);
+  if (!myVersionMatch) {
+    return function() {
+      return false;
+    };
+  }
+  var ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    var globalVersionMatch = globalVersion.match(re$1);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    var globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var isCompatible = _makeCompatibilityCheck(VERSION);
+var major = VERSION.split(".")[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+var _global = _globalThis;
+function registerGlobal(type, instance, diag, allowOverride) {
+  var _a;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+var __read$3 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r2, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r2 = i.next()).done) ar.push(r2.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray$4 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var DiagComponentLogger = (
+  /** @class */
+  (function() {
+    function DiagComponentLogger2(props) {
+      this._namespace = props.namespace || "DiagComponentLogger";
+    }
+    DiagComponentLogger2.prototype.debug = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("debug", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.error = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("error", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.info = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("info", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.warn = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("warn", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.verbose = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("verbose", this._namespace, args);
+    };
+    return DiagComponentLogger2;
+  })()
+);
+function logProxy(funcName, namespace, args) {
+  var logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray$4([], __read$3(args), false));
+}
+var DiagLogLevel;
+(function(DiagLogLevel2) {
+  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    var theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+var __read$2 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r2, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r2 = i.next()).done) ar.push(r2.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray$3 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var API_NAME$2 = "diag";
+var DiagAPI = (
+  /** @class */
+  (function() {
+    function DiagAPI2() {
+      function _logProxy(funcName) {
+        return function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var logger = getGlobal("diag");
+          if (!logger)
+            return;
+          return logger[funcName].apply(logger, __spreadArray$3([], __read$2(args), false));
+        };
+      }
+      var self2 = this;
+      var setLogger = function(logger, optionsOrLogLevel) {
+        var _a, _b, _c;
+        if (optionsOrLogLevel === void 0) {
+          optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+        }
+        if (logger === self2) {
+          var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+          return false;
+        }
+        if (typeof optionsOrLogLevel === "number") {
+          optionsOrLogLevel = {
+            logLevel: optionsOrLogLevel
+          };
+        }
+        var oldLogger = getGlobal("diag");
+        var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+          var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+          oldLogger.warn("Current logger will be overwritten from " + stack);
+          newLogger.warn("Current logger will overwrite one already registered from " + stack);
+        }
+        return registerGlobal("diag", newLogger, self2, true);
+      };
+      self2.setLogger = setLogger;
+      self2.disable = function() {
+        unregisterGlobal(API_NAME$2, self2);
+      };
+      self2.createComponentLogger = function(options) {
+        return new DiagComponentLogger(options);
+      };
+      self2.verbose = _logProxy("verbose");
+      self2.debug = _logProxy("debug");
+      self2.info = _logProxy("info");
+      self2.warn = _logProxy("warn");
+      self2.error = _logProxy("error");
+    }
+    DiagAPI2.instance = function() {
+      if (!this._instance) {
+        this._instance = new DiagAPI2();
+      }
+      return this._instance;
+    };
+    return DiagAPI2;
+  })()
+);
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+var BaseContext = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function BaseContext2(parentContext) {
+      var self2 = this;
+      self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+      self2.getValue = function(key2) {
+        return self2._currentContext.get(key2);
+      };
+      self2.setValue = function(key2, value) {
+        var context2 = new BaseContext2(self2._currentContext);
+        context2._currentContext.set(key2, value);
+        return context2;
+      };
+      self2.deleteValue = function(key2) {
+        var context2 = new BaseContext2(self2._currentContext);
+        context2._currentContext.delete(key2);
+        return context2;
+      };
+    }
+    return BaseContext2;
+  })()
+);
+var ROOT_CONTEXT = new BaseContext();
+var __read$1 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r2, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r2 = i.next()).done) ar.push(r2.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray$2 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var NoopContextManager = (
+  /** @class */
+  (function() {
+    function NoopContextManager2() {
+    }
+    NoopContextManager2.prototype.active = function() {
+      return ROOT_CONTEXT;
+    };
+    NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
+      var args = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+      }
+      return fn.call.apply(fn, __spreadArray$2([thisArg], __read$1(args), false));
+    };
+    NoopContextManager2.prototype.bind = function(_context, target) {
+      return target;
+    };
+    NoopContextManager2.prototype.enable = function() {
+      return this;
+    };
+    NoopContextManager2.prototype.disable = function() {
+      return this;
+    };
+    return NoopContextManager2;
+  })()
+);
+var __read = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r2, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r2 = i.next()).done) ar.push(r2.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r2 && !r2.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray$1 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var API_NAME$1 = "context";
+var NOOP_CONTEXT_MANAGER = new NoopContextManager();
+var ContextAPI = (
+  /** @class */
+  (function() {
+    function ContextAPI2() {
+    }
+    ContextAPI2.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new ContextAPI2();
+      }
+      return this._instance;
+    };
+    ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
+      return registerGlobal(API_NAME$1, contextManager, DiagAPI.instance());
+    };
+    ContextAPI2.prototype.active = function() {
+      return this._getContextManager().active();
+    };
+    ContextAPI2.prototype.with = function(context2, fn, thisArg) {
+      var _a;
+      var args = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+      }
+      return (_a = this._getContextManager()).with.apply(_a, __spreadArray$1([context2, fn, thisArg], __read(args), false));
+    };
+    ContextAPI2.prototype.bind = function(context2, target) {
+      return this._getContextManager().bind(context2, target);
+    };
+    ContextAPI2.prototype._getContextManager = function() {
+      return getGlobal(API_NAME$1) || NOOP_CONTEXT_MANAGER;
+    };
+    ContextAPI2.prototype.disable = function() {
+      this._getContextManager().disable();
+      unregisterGlobal(API_NAME$1, DiagAPI.instance());
+    };
+    return ContextAPI2;
+  })()
+);
+var TraceFlags;
+(function(TraceFlags2) {
+  TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+  TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+})(TraceFlags || (TraceFlags = {}));
+var INVALID_SPANID = "0000000000000000";
+var INVALID_TRACEID = "00000000000000000000000000000000";
+var INVALID_SPAN_CONTEXT = {
+  traceId: INVALID_TRACEID,
+  spanId: INVALID_SPANID,
+  traceFlags: TraceFlags.NONE
+};
+var NonRecordingSpan = (
+  /** @class */
+  (function() {
+    function NonRecordingSpan2(_spanContext) {
+      if (_spanContext === void 0) {
+        _spanContext = INVALID_SPAN_CONTEXT;
+      }
+      this._spanContext = _spanContext;
+    }
+    NonRecordingSpan2.prototype.spanContext = function() {
+      return this._spanContext;
+    };
+    NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addLink = function(_link) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addLinks = function(_links) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.setStatus = function(_status) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.updateName = function(_name) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.end = function(_endTime) {
+    };
+    NonRecordingSpan2.prototype.isRecording = function() {
+      return false;
+    };
+    NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
+    };
+    return NonRecordingSpan2;
+  })()
+);
+var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
+}
+function getActiveSpan$1() {
+  return getSpan(ContextAPI.getInstance().active());
+}
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
+}
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
+}
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
+}
+function getSpanContext(context2) {
+  var _a;
+  return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
+}
+var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+function isValidTraceId(traceId) {
+  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
+}
+function isValidSpanId(spanId) {
+  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
+}
+function isSpanContextValid(spanContext) {
+  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+function wrapSpanContext(spanContext) {
+  return new NonRecordingSpan(spanContext);
+}
+var contextApi = ContextAPI.getInstance();
+var NoopTracer = (
+  /** @class */
+  (function() {
+    function NoopTracer2() {
+    }
+    NoopTracer2.prototype.startSpan = function(name2, options, context2) {
+      if (context2 === void 0) {
+        context2 = contextApi.active();
+      }
+      var root2 = Boolean(options === null || options === void 0 ? void 0 : options.root);
+      if (root2) {
+        return new NonRecordingSpan();
+      }
+      var parentFromContext = context2 && getSpanContext(context2);
+      if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+        return new NonRecordingSpan(parentFromContext);
+      } else {
+        return new NonRecordingSpan();
+      }
+    };
+    NoopTracer2.prototype.startActiveSpan = function(name2, arg2, arg3, arg4) {
+      var opts;
+      var ctx;
+      var fn;
+      if (arguments.length < 2) {
+        return;
+      } else if (arguments.length === 2) {
+        fn = arg2;
+      } else if (arguments.length === 3) {
+        opts = arg2;
+        fn = arg3;
+      } else {
+        opts = arg2;
+        ctx = arg3;
+        fn = arg4;
+      }
+      var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+      var span = this.startSpan(name2, opts, parentContext);
+      var contextWithSpanSet = setSpan(parentContext, span);
+      return contextApi.with(contextWithSpanSet, fn, void 0, span);
+    };
+    return NoopTracer2;
+  })()
+);
+function isSpanContext(spanContext) {
+  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+}
+var NOOP_TRACER = new NoopTracer();
+var ProxyTracer = (
+  /** @class */
+  (function() {
+    function ProxyTracer2(_provider, name2, version, options) {
+      this._provider = _provider;
+      this.name = name2;
+      this.version = version;
+      this.options = options;
+    }
+    ProxyTracer2.prototype.startSpan = function(name2, options, context2) {
+      return this._getTracer().startSpan(name2, options, context2);
+    };
+    ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
+      var tracer = this._getTracer();
+      return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+    };
+    ProxyTracer2.prototype._getTracer = function() {
+      if (this._delegate) {
+        return this._delegate;
+      }
+      var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+      if (!tracer) {
+        return NOOP_TRACER;
+      }
+      this._delegate = tracer;
+      return this._delegate;
+    };
+    return ProxyTracer2;
+  })()
+);
+var NoopTracerProvider = (
+  /** @class */
+  (function() {
+    function NoopTracerProvider2() {
+    }
+    NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
+      return new NoopTracer();
+    };
+    return NoopTracerProvider2;
+  })()
+);
+var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+var ProxyTracerProvider = (
+  /** @class */
+  (function() {
+    function ProxyTracerProvider2() {
+    }
+    ProxyTracerProvider2.prototype.getTracer = function(name2, version, options) {
+      var _a;
+      return (_a = this.getDelegateTracer(name2, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name2, version, options);
+    };
+    ProxyTracerProvider2.prototype.getDelegate = function() {
+      var _a;
+      return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+    };
+    ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
+      this._delegate = delegate;
+    };
+    ProxyTracerProvider2.prototype.getDelegateTracer = function(name2, version, options) {
+      var _a;
+      return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name2, version, options);
+    };
+    return ProxyTracerProvider2;
+  })()
+);
+var SpanStatusCode;
+(function(SpanStatusCode2) {
+  SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+  SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+  SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+var context = ContextAPI.getInstance();
+var API_NAME = "trace";
+var TraceAPI = (
+  /** @class */
+  (function() {
+    function TraceAPI2() {
+      this._proxyTracerProvider = new ProxyTracerProvider();
+      this.wrapSpanContext = wrapSpanContext;
+      this.isSpanContextValid = isSpanContextValid;
+      this.deleteSpan = deleteSpan;
+      this.getSpan = getSpan;
+      this.getActiveSpan = getActiveSpan$1;
+      this.getSpanContext = getSpanContext;
+      this.setSpan = setSpan;
+      this.setSpanContext = setSpanContext;
+    }
+    TraceAPI2.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new TraceAPI2();
+      }
+      return this._instance;
+    };
+    TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
+      var success = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());
+      if (success) {
+        this._proxyTracerProvider.setDelegate(provider);
+      }
+      return success;
+    };
+    TraceAPI2.prototype.getTracerProvider = function() {
+      return getGlobal(API_NAME) || this._proxyTracerProvider;
+    };
+    TraceAPI2.prototype.getTracer = function(name2, version) {
+      return this.getTracerProvider().getTracer(name2, version);
+    };
+    TraceAPI2.prototype.disable = function() {
+      unregisterGlobal(API_NAME, DiagAPI.instance());
+      this._proxyTracerProvider = new ProxyTracerProvider();
+    };
+    return TraceAPI2;
+  })()
+);
+var trace = TraceAPI.getInstance();
+const PACKAGE_VERSION = "1.0.41";
+const TRACER_NAME = "@industry-theme/backlogmd-kanban-panel";
+const TRACER_VERSION = PACKAGE_VERSION;
+function getTracer() {
+  return trace.getTracer(TRACER_NAME, TRACER_VERSION);
+}
+function getActiveSpan() {
+  return trace.getActiveSpan();
+}
+async function withSpan(span, fn) {
+  return context.with(trace.setSpan(context.active(), span), fn);
+}
 const STATUS_COLUMNS = [
   DEFAULT_TASK_STATUSES.TODO,
   DEFAULT_TASK_STATUSES.IN_PROGRESS,
@@ -7989,7 +8707,7 @@ const STATUS_COLUMNS = [
 const DEFAULT_TASKS_LIMIT = 20;
 function useKanbanData(options) {
   const {
-    context,
+    context: context2,
     actions,
     tasksLimit = DEFAULT_TASKS_LIMIT,
     events: events2
@@ -8008,12 +8726,12 @@ function useKanbanData(options) {
   const [isLoadingMore, setIsLoadingMore] = useState(false);
   const coreRef = useRef(null);
   const activeFilePathRef = useRef(null);
-  const contextRef = useRef(context);
+  const contextRef = useRef(context2);
   const actionsRef = useRef(actions);
   useEffect(() => {
-    contextRef.current = context;
+    contextRef.current = context2;
     actionsRef.current = actions;
-  }, [context, actions]);
+  }, [context2, actions]);
   const fetchFileContent = useCallback(async (path2) => {
     var _a;
     const currentContext = contextRef.current;
@@ -8049,8 +8767,12 @@ function useKanbanData(options) {
     return newColumnStates;
   }, []);
   const loadBacklogData = useCallback(async () => {
-    var _a, _b, _c;
-    if (!context || !actions) {
+    var _a, _b;
+    const tracer = getTracer();
+    const span = tracer.startSpan("kanban.load");
+    const startTime = Date.now();
+    span.addEvent("kanban.loading");
+    if (!context2 || !actions) {
       console.log("[useKanbanData] No context provided");
       setIsBacklogProject(false);
       setTasks([]);
@@ -8058,9 +8780,12 @@ function useKanbanData(options) {
       setIsLoading(false);
       coreRef.current = null;
       fileTreeVersionRef.current = null;
+      span.setAttributes({ "output.skipped": true, "output.reason": "no_context" });
+      span.setStatus({ code: SpanStatusCode.OK });
+      span.end();
       return;
     }
-    const fileTreeSlice = context.fileTree;
+    const fileTreeSlice = context2.fileTree;
     if (!((_a = fileTreeSlice == null ? void 0 : fileTreeSlice.data) == null ? void 0 : _a.allFiles)) {
       console.log("[useKanbanData] FileTree not available");
       setIsBacklogProject(false);
@@ -8068,79 +8793,115 @@ function useKanbanData(options) {
       setColumnStates(/* @__PURE__ */ new Map());
       coreRef.current = null;
       fileTreeVersionRef.current = null;
+      span.setAttributes({ "output.skipped": true, "output.reason": "no_filetree" });
+      span.setStatus({ code: SpanStatusCode.OK });
+      span.end();
       return;
     }
     const currentVersion = fileTreeSlice.data.sha || ((_b = fileTreeSlice.data.metadata) == null ? void 0 : _b.sourceSha) || "unknown";
     if (coreRef.current && fileTreeVersionRef.current === currentVersion) {
       console.log("[useKanbanData] Data already loaded for this file tree version, skipping");
       setIsLoading(false);
+      span.setAttributes({ "output.skipped": true, "output.reason": "already_loaded" });
+      span.setStatus({ code: SpanStatusCode.OK });
+      span.end();
       return;
     }
     setIsLoading(true);
     setError(null);
-    try {
-      const files = fileTreeSlice.data.allFiles;
-      const filePaths = files.map((f) => f.path);
-      const fs = new PanelFileSystemAdapter({
-        fetchFile: fetchFileContent,
-        filePaths,
-        hostFileSystem: (_c = context.adapters) == null ? void 0 : _c.fileSystem
-      });
-      const core2 = new Core({
-        projectRoot: "",
-        adapters: { fs }
-      });
-      const isProject = await core2.isBacklogProject();
-      if (!isProject) {
-        console.log("[useKanbanData] Not a Backlog.md project");
+    const files = fileTreeSlice.data.allFiles;
+    const filePaths = files.map((f) => f.path);
+    return withSpan(span, async () => {
+      var _a2;
+      try {
+        const fs = new PanelFileSystemAdapter({
+          fetchFile: fetchFileContent,
+          filePaths,
+          hostFileSystem: (_a2 = context2.adapters) == null ? void 0 : _a2.fileSystem
+        });
+        const core2 = new Core({
+          projectRoot: "",
+          adapters: { fs }
+        });
+        const isProject = await core2.isBacklogProject();
+        if (!isProject) {
+          console.log("[useKanbanData] Not a Backlog.md project");
+          setIsBacklogProject(false);
+          setTasks([]);
+          setColumnStates(/* @__PURE__ */ new Map());
+          coreRef.current = null;
+          span.setAttributes({
+            "output.isBacklogProject": false,
+            "duration.ms": Date.now() - startTime
+          });
+          span.addEvent("kanban.loaded", { "tasks.count": 0, "is.backlog.project": false });
+          span.setStatus({ code: SpanStatusCode.OK });
+          return;
+        }
+        console.log("[useKanbanData] Loading Backlog.md data with lazy loading...");
+        setIsBacklogProject(true);
+        setCanWrite(fs.canWrite);
+        await core2.initializeLazy(filePaths);
+        coreRef.current = core2;
+        const paginatedResult = await core2.loadMoreForSource("tasks", 0, {
+          limit: tasksLimit,
+          sortDirection: "asc"
+        });
+        const allTasks = paginatedResult.items;
+        const total = paginatedResult.total;
+        console.log(
+          `[useKanbanData] Loaded ${allTasks.length}/${total} tasks`
+        );
+        if (allTasks.length > 0) {
+          console.log("[useKanbanData] First task sample:", {
+            id: allTasks[0].id,
+            title: allTasks[0].title,
+            status: allTasks[0].status,
+            description: allTasks[0].description,
+            filePath: allTasks[0].filePath
+          });
+        }
+        fileTreeVersionRef.current = currentVersion;
+        const newColumnStates = buildColumnStates(allTasks);
+        setTasks(allTasks);
+        setColumnStates(newColumnStates);
+        setTotalLoaded(allTasks.length);
+        setTotalCount(total);
+        setHasMore(paginatedResult.hasMore);
+        span.addEvent("kanban.loaded", {
+          "tasks.count": allTasks.length,
+          "tasks.total": total,
+          "tasks.hasMore": paginatedResult.hasMore
+        });
+        span.setAttributes({
+          "output.isBacklogProject": true,
+          "output.tasksLoaded": allTasks.length,
+          "output.tasksTotal": total,
+          "output.hasMore": paginatedResult.hasMore,
+          "duration.ms": Date.now() - startTime
+        });
+        span.setStatus({ code: SpanStatusCode.OK });
+      } catch (err) {
+        console.error("[useKanbanData] Failed to load Backlog.md data:", err);
+        const errorMessage = err instanceof Error ? err.message : "Failed to load backlog data";
+        setError(errorMessage);
         setIsBacklogProject(false);
         setTasks([]);
         setColumnStates(/* @__PURE__ */ new Map());
         coreRef.current = null;
-        return;
-      }
-      console.log("[useKanbanData] Loading Backlog.md data with lazy loading...");
-      setIsBacklogProject(true);
-      setCanWrite(fs.canWrite);
-      await core2.initializeLazy(filePaths);
-      coreRef.current = core2;
-      const paginatedResult = await core2.loadMoreForSource("tasks", 0, {
-        limit: tasksLimit,
-        sortDirection: "asc"
-      });
-      const allTasks = paginatedResult.items;
-      const total = paginatedResult.total;
-      console.log(
-        `[useKanbanData] Loaded ${allTasks.length}/${total} tasks`
-      );
-      if (allTasks.length > 0) {
-        console.log("[useKanbanData] First task sample:", {
-          id: allTasks[0].id,
-          title: allTasks[0].title,
-          status: allTasks[0].status,
-          description: allTasks[0].description,
-          filePath: allTasks[0].filePath
+        fileTreeVersionRef.current = null;
+        span.addEvent("kanban.load.error", {
+          "error.type": err instanceof Error ? err.name : "Unknown",
+          "error.message": errorMessage
         });
+        span.recordException(err);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+      } finally {
+        setIsLoading(false);
+        span.end();
       }
-      fileTreeVersionRef.current = currentVersion;
-      const newColumnStates = buildColumnStates(allTasks);
-      setTasks(allTasks);
-      setColumnStates(newColumnStates);
-      setTotalLoaded(allTasks.length);
-      setTotalCount(total);
-      setHasMore(paginatedResult.hasMore);
-    } catch (err) {
-      console.error("[useKanbanData] Failed to load Backlog.md data:", err);
-      setError(err instanceof Error ? err.message : "Failed to load backlog data");
-      setIsBacklogProject(false);
-      setTasks([]);
-      setColumnStates(/* @__PURE__ */ new Map());
-      coreRef.current = null;
-      fileTreeVersionRef.current = null;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [context, actions, fetchFileContent, tasksLimit, buildColumnStates]);
+    });
+  }, [context2, actions, fetchFileContent, tasksLimit, buildColumnStates]);
   useEffect(() => {
     loadBacklogData();
   }, [loadBacklogData]);
@@ -8166,28 +8927,61 @@ function useKanbanData(options) {
     if (!hasMore || isLoadingMore) {
       return;
     }
+    const tracer = getTracer();
+    const span = tracer.startSpan("kanban.load.more", {
+      attributes: {
+        "input.offset": totalLoaded,
+        "input.limit": tasksLimit
+      }
+    });
+    const startTime = Date.now();
     setIsLoadingMore(true);
-    try {
-      const result = await core2.loadMoreForSource("tasks", totalLoaded, {
-        limit: tasksLimit,
-        sortDirection: "asc"
-      });
-      console.log(
-        `[useKanbanData] Loaded ${result.items.length} more tasks (${totalLoaded + result.items.length}/${result.total})`
-      );
-      const newTasks = [...tasks, ...result.items];
-      setTasks(newTasks);
-      setTotalLoaded(newTasks.length);
-      setTotalCount(result.total);
-      setHasMore(result.hasMore);
-      const newColumnStates = buildColumnStates(newTasks);
-      setColumnStates(newColumnStates);
-    } catch (err) {
-      console.error("[useKanbanData] Failed to load more tasks:", err);
-      setError(err instanceof Error ? err.message : "Failed to load more tasks");
-    } finally {
-      setIsLoadingMore(false);
-    }
+    return withSpan(span, async () => {
+      try {
+        span.addEvent("kanban.load.more", {
+          offset: totalLoaded,
+          limit: tasksLimit
+        });
+        const result = await core2.loadMoreForSource("tasks", totalLoaded, {
+          limit: tasksLimit,
+          sortDirection: "asc"
+        });
+        console.log(
+          `[useKanbanData] Loaded ${result.items.length} more tasks (${totalLoaded + result.items.length}/${result.total})`
+        );
+        const newTasks = [...tasks, ...result.items];
+        setTasks(newTasks);
+        setTotalLoaded(newTasks.length);
+        setTotalCount(result.total);
+        setHasMore(result.hasMore);
+        const newColumnStates = buildColumnStates(newTasks);
+        setColumnStates(newColumnStates);
+        span.addEvent("kanban.loaded", {
+          "tasks.count": newTasks.length,
+          "tasks.newlyLoaded": result.items.length
+        });
+        span.setAttributes({
+          "output.tasksLoaded": result.items.length,
+          "output.totalTasks": newTasks.length,
+          "output.hasMore": result.hasMore,
+          "duration.ms": Date.now() - startTime
+        });
+        span.setStatus({ code: SpanStatusCode.OK });
+      } catch (err) {
+        console.error("[useKanbanData] Failed to load more tasks:", err);
+        const errorMessage = err instanceof Error ? err.message : "Failed to load more tasks";
+        setError(errorMessage);
+        span.addEvent("kanban.load.error", {
+          "error.type": err instanceof Error ? err.name : "Unknown",
+          "error.message": errorMessage
+        });
+        span.recordException(err);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+      } finally {
+        setIsLoadingMore(false);
+        span.end();
+      }
+    });
   }, [tasks, hasMore, isLoadingMore, totalLoaded, tasksLimit, buildColumnStates]);
   const loadMore = useCallback(
     async (_status) => {
@@ -8201,9 +8995,15 @@ function useKanbanData(options) {
   const updateTaskStatus = useCallback(
     async (taskId, newStatus) => {
       const core2 = coreRef.current;
+      const activeSpan = getActiveSpan();
       if (!core2) {
         console.warn("[useKanbanData] Core not available for updateTaskStatus");
         setError("Cannot update task - backlog not loaded");
+        activeSpan == null ? void 0 : activeSpan.addEvent("task.save.error", {
+          "error.type": "CoreNotAvailable",
+          "error.message": "Cannot update task - backlog not loaded",
+          "task.id": taskId
+        });
         return;
       }
       setError(null);
@@ -8214,10 +9014,21 @@ function useKanbanData(options) {
           throw new Error(`Task ${taskId} not found`);
         }
         console.log(`[useKanbanData] Task ${taskId} updated successfully`);
+        activeSpan == null ? void 0 : activeSpan.addEvent("task.updated", {
+          "task.id": taskId,
+          "task.status": newStatus,
+          "updated.fields": "status"
+        });
         await loadBacklogData();
       } catch (err) {
         console.error("[useKanbanData] Failed to update task status:", err);
-        setError(err instanceof Error ? err.message : "Failed to update task");
+        const errorMessage = err instanceof Error ? err.message : "Failed to update task";
+        setError(errorMessage);
+        activeSpan == null ? void 0 : activeSpan.addEvent("task.save.error", {
+          "error.type": err instanceof Error ? err.name : "Unknown",
+          "error.message": errorMessage,
+          "task.id": taskId
+        });
       }
     },
     [loadBacklogData]
@@ -8225,13 +9036,21 @@ function useKanbanData(options) {
   const moveTaskOptimistic = useCallback(
     (taskId, toColumn) => {
       const newStatus = toColumn;
+      const activeSpan = getActiveSpan();
       setTasks((prev) => {
+        const task = prev.find((t) => t.id === taskId);
+        const fromStatus = (task == null ? void 0 : task.status) || "unknown";
         const newTasks = prev.map(
           (t) => t.id === taskId ? { ...t, status: newStatus } : t
         );
         const newColumnStates = buildColumnStates(newTasks);
         setColumnStates(newColumnStates);
         console.log(`[useKanbanData] Moved task ${taskId} to ${toColumn} (${newStatus})`);
+        activeSpan == null ? void 0 : activeSpan.addEvent("task.moved", {
+          "task.id": taskId,
+          "from.status": fromStatus,
+          "to.status": newStatus
+        });
         return newTasks;
       });
     },
@@ -8411,7 +9230,7 @@ const TaskCard = ({
       zIndex: 1e3
     }
   };
-  const handleClick = (e) => {
+  const handleClick = (_e2) => {
     if (!isDragging && onClick) {
       onClick(task);
     }
@@ -9061,6 +9880,20 @@ const BoardEmptyState = ({
   canWrite
 }) => {
   const { theme: theme2 } = useTheme();
+  const handleAddTask = useCallback(() => {
+    const activeSpan = getActiveSpan();
+    activeSpan == null ? void 0 : activeSpan.addEvent("empty.action.clicked", {
+      "action.type": "add_task"
+    });
+    onAddTask();
+  }, [onAddTask]);
+  const handleAddMilestone = useCallback(() => {
+    const activeSpan = getActiveSpan();
+    activeSpan == null ? void 0 : activeSpan.addEvent("empty.action.clicked", {
+      "action.type": "add_milestone"
+    });
+    onAddMilestone();
+  }, [onAddMilestone]);
   return /* @__PURE__ */ jsxs(
     "div",
     {
@@ -9120,7 +9953,7 @@ const BoardEmptyState = ({
               /* @__PURE__ */ jsxs(
                 "button",
                 {
-                  onClick: onAddTask,
+                  onClick: handleAddTask,
                   style: {
                     display: "inline-flex",
                     alignItems: "center",
@@ -9150,7 +9983,7 @@ const BoardEmptyState = ({
               /* @__PURE__ */ jsxs(
                 "button",
                 {
-                  onClick: onAddMilestone,
+                  onClick: handleAddMilestone,
                   style: {
                     display: "inline-flex",
                     alignItems: "center",
@@ -9709,7 +10542,7 @@ const TaskModal = ({
   return createPortal(modalContent, document.body);
 };
 function useMilestoneData(options) {
-  const { context, actions } = options || {};
+  const { context: context2, actions } = options || {};
   const [milestones, setMilestones] = useState([]);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState(null);
@@ -9717,12 +10550,12 @@ function useMilestoneData(options) {
   const [canWrite, setCanWrite] = useState(false);
   const coreRef = useRef(null);
   const activeFilePathRef = useRef(null);
-  const contextRef = useRef(context);
+  const contextRef = useRef(context2);
   const actionsRef = useRef(actions);
   useEffect(() => {
-    contextRef.current = context;
+    contextRef.current = context2;
     actionsRef.current = actions;
-  }, [context, actions]);
+  }, [context2, actions]);
   const fetchFileContent = useCallback(async (path2) => {
     var _a;
     const currentContext = contextRef.current;
@@ -9746,7 +10579,7 @@ function useMilestoneData(options) {
   const fileTreeVersionRef = useRef(null);
   const loadMilestoneData = useCallback(async () => {
     var _a, _b, _c;
-    if (!context || !actions) {
+    if (!context2 || !actions) {
       console.log("[useMilestoneData] No context provided");
       setIsBacklogProject(false);
       setMilestones([]);
@@ -9755,7 +10588,7 @@ function useMilestoneData(options) {
       fileTreeVersionRef.current = null;
       return;
     }
-    const fileTreeSlice = context.fileTree;
+    const fileTreeSlice = context2.fileTree;
     if (!((_a = fileTreeSlice == null ? void 0 : fileTreeSlice.data) == null ? void 0 : _a.allFiles)) {
       console.log("[useMilestoneData] FileTree not available");
       setIsBacklogProject(false);
@@ -9783,7 +10616,7 @@ function useMilestoneData(options) {
       const fs = new PanelFileSystemAdapter({
         fetchFile: fetchFileContent,
         filePaths,
-        hostFileSystem: (_c = context.adapters) == null ? void 0 : _c.fileSystem
+        hostFileSystem: (_c = context2.adapters) == null ? void 0 : _c.fileSystem
       });
       const core2 = new Core({
         projectRoot: "",
@@ -9856,7 +10689,7 @@ function useMilestoneData(options) {
     } finally {
       setIsLoading(false);
     }
-  }, [context, actions, fetchFileContent]);
+  }, [context2, actions, fetchFileContent]);
   useEffect(() => {
     loadMilestoneData();
   }, [loadMilestoneData]);
@@ -10240,7 +11073,7 @@ const MilestoneModal = ({
   return createPortal(modalContent, document.body);
 };
 const KanbanPanel = ({
-  context,
+  context: context2,
   actions,
   events: events2
 }) => {
@@ -10260,6 +11093,27 @@ const KanbanPanel = ({
   const [selectedMilestoneId, setSelectedMilestoneId] = useState(null);
   const [milestoneStatusFilter, setMilestoneStatusFilter] = useState(null);
   const [searchQuery, setSearchQuery] = useState("");
+  const searchDebounceRef = useRef(null);
+  const handleSearchChange = useCallback((value) => {
+    setSearchQuery(value);
+    if (searchDebounceRef.current) {
+      clearTimeout(searchDebounceRef.current);
+    }
+    searchDebounceRef.current = setTimeout(() => {
+      const activeSpan = getActiveSpan();
+      if (value.trim()) {
+        activeSpan == null ? void 0 : activeSpan.addEvent("search.performed", {
+          "search.query": value.trim()
+          // Note: results.count is approximate since filteredTasksByStatus updates async
+        });
+      }
+    }, 500);
+  }, []);
+  const handleClearSearch = useCallback(() => {
+    setSearchQuery("");
+    const activeSpan = getActiveSpan();
+    activeSpan == null ? void 0 : activeSpan.addEvent("filter.cleared");
+  }, []);
   const sensors = useSensors(
     useSensor(PointerSensor, {
       activationConstraint: {
@@ -10316,7 +11170,7 @@ const KanbanPanel = ({
     canWrite,
     core: core2
   } = useKanbanData({
-    context,
+    context: context2,
     actions,
     events: events2,
     tasksLimit: 20
@@ -10329,7 +11183,7 @@ const KanbanPanel = ({
     canWrite: canWriteMilestones,
     core: milestoneCore
   } = useMilestoneData({
-    context,
+    context: context2,
     actions
   });
   const filteredTasksByStatus = useMemo(() => {
@@ -10352,28 +11206,84 @@ const KanbanPanel = ({
     }
     return filtered;
   }, [tasksByStatus, searchQuery]);
+  const dragSpanRef = useRef(null);
   const handleDragStart = useCallback((event) => {
     const { active } = event;
     const task = getTaskById(active.id);
     if (task) {
       setActiveTask(task);
+      const tracer = getTracer();
+      const span = tracer.startSpan("task.edit", {
+        attributes: {
+          "input.taskId": task.id,
+          "input.fromStatus": task.status || "unknown"
+        }
+      });
+      dragSpanRef.current = span;
+      span.addEvent("task.drag.started", {
+        "task.id": task.id,
+        "from.status": task.status || "unknown"
+      });
     }
   }, [getTaskById]);
   const handleDragEnd = useCallback((event) => {
     const { active, over } = event;
+    const span = dragSpanRef.current;
     setActiveTask(null);
-    if (!over) return;
+    if (!over) {
+      if (span) {
+        span.addEvent("task.drag.cancelled");
+        span.setAttributes({ "output.cancelled": true });
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+        dragSpanRef.current = null;
+      }
+      return;
+    }
     const taskId = active.id;
     const targetColumn = over.id;
     const task = getTaskById(taskId);
-    if (!task) return;
+    if (!task) {
+      if (span) {
+        span.setStatus({ code: SpanStatusCode.ERROR, message: "Task not found" });
+        span.end();
+        dragSpanRef.current = null;
+      }
+      return;
+    }
     const currentColumn = task.status || DEFAULT_TASK_STATUSES.TODO;
     if (currentColumn !== targetColumn) {
-      moveTaskOptimistic(taskId, targetColumn);
+      if (span) {
+        withSpan(span, async () => {
+          moveTaskOptimistic(taskId, targetColumn);
+        });
+        span.setAttributes({
+          "output.toStatus": targetColumn,
+          "output.moved": true
+        });
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+        dragSpanRef.current = null;
+      } else {
+        moveTaskOptimistic(taskId, targetColumn);
+      }
+    } else {
+      if (span) {
+        span.addEvent("task.drag.cancelled");
+        span.setAttributes({ "output.cancelled": true, "output.reason": "same_column" });
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+        dragSpanRef.current = null;
+      }
     }
   }, [getTaskById, moveTaskOptimistic]);
   const handleTaskClick = (task) => {
     setSelectedTaskId(task.id);
+    const activeSpan = getActiveSpan();
+    activeSpan == null ? void 0 : activeSpan.addEvent("task.selected", {
+      "task.id": task.id,
+      "task.status": task.status || "unknown"
+    });
     if (events2) {
       events2.emit({
         type: "task:selected",
@@ -10383,16 +11293,16 @@ const KanbanPanel = ({
       });
     }
   };
-  const fileSystem = (_a = context.adapters) == null ? void 0 : _a.fileSystem;
+  const fileSystem = (_a = context2.adapters) == null ? void 0 : _a.fileSystem;
   const canInitialize = Boolean(
-    (fileSystem == null ? void 0 : fileSystem.writeFile) && (fileSystem == null ? void 0 : fileSystem.createDir) && ((_b = context.currentScope.repository) == null ? void 0 : _b.path)
+    (fileSystem == null ? void 0 : fileSystem.writeFile) && (fileSystem == null ? void 0 : fileSystem.createDir) && ((_b = context2.currentScope.repository) == null ? void 0 : _b.path)
   );
   const handleInitialize = useCallback(async () => {
     var _a2, _b2;
     if (!(fileSystem == null ? void 0 : fileSystem.writeFile) || !(fileSystem == null ? void 0 : fileSystem.createDir)) {
       throw new Error("File system adapter not available");
     }
-    const repoPath = (_a2 = context.currentScope.repository) == null ? void 0 : _a2.path;
+    const repoPath = (_a2 = context2.currentScope.repository) == null ? void 0 : _a2.path;
     if (!repoPath) {
       throw new Error("Repository path not available");
     }
@@ -10439,32 +11349,80 @@ const KanbanPanel = ({
       projectRoot: repoPath,
       adapters: { fs: fsAdapter }
     });
-    const projectName = ((_b2 = context.currentScope.repository) == null ? void 0 : _b2.name) || "Backlog";
+    const projectName = ((_b2 = context2.currentScope.repository) == null ? void 0 : _b2.name) || "Backlog";
     await core22.initProject({ projectName });
     await refreshData();
-  }, [fileSystem, context.currentScope.repository, refreshData]);
+  }, [fileSystem, context2.currentScope.repository, refreshData]);
+  const taskSaveCompletedRef = useRef(false);
+  const taskModalSpanRef = useRef(null);
   const handleOpenNewTask = useCallback(() => {
     setEditingTask(void 0);
     setIsTaskModalOpen(true);
-  }, []);
-  useCallback((task) => {
-    setEditingTask(task);
-    setIsTaskModalOpen(true);
+    taskSaveCompletedRef.current = false;
+    const tracer = getTracer();
+    const span = tracer.startSpan("task.create");
+    taskModalSpanRef.current = span;
+    span.addEvent("modal.opened", {
+      "modal.type": "task",
+      "modal.mode": "create"
+    });
   }, []);
   const handleCloseTaskModal = useCallback(() => {
+    const span = taskModalSpanRef.current;
+    if (!taskSaveCompletedRef.current && span) {
+      span.addEvent("modal.cancelled", {
+        "had.changes": false
+        // We don't track dirty state yet
+      });
+      span.setAttributes({ "output.cancelled": true });
+      span.setStatus({ code: SpanStatusCode.OK });
+      span.end();
+    }
     setIsTaskModalOpen(false);
     setEditingTask(void 0);
+    taskModalSpanRef.current = null;
   }, []);
   const handleSaveTask = useCallback(async (input) => {
     if (!core2) {
       throw new Error("Backlog not loaded");
     }
-    if (editingTask) {
-      await core2.updateTask(editingTask.id, input);
-    } else {
-      await core2.createTask(input);
+    const span = taskModalSpanRef.current;
+    const isEditing = !!editingTask;
+    try {
+      if (isEditing) {
+        await core2.updateTask(editingTask.id, input);
+        span == null ? void 0 : span.addEvent("task.updated", {
+          "task.id": editingTask.id,
+          "updated.fields": Object.keys(input).join(", ")
+        });
+      } else {
+        const newTask = await core2.createTask(input);
+        span == null ? void 0 : span.addEvent("task.created", {
+          "task.id": (newTask == null ? void 0 : newTask.id) || "unknown",
+          "task.status": input.status || "To Do"
+        });
+      }
+      taskSaveCompletedRef.current = true;
+      if (span) {
+        span.setAttributes({
+          "output.success": true,
+          "output.operation": isEditing ? "update" : "create"
+        });
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+        taskModalSpanRef.current = null;
+      }
+      await refreshData();
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to save task";
+      span == null ? void 0 : span.addEvent("task.save.error", {
+        "error.type": err instanceof Error ? err.name : "Unknown",
+        "error.message": errorMessage
+      });
+      span == null ? void 0 : span.recordException(err);
+      span == null ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+      throw err;
     }
-    await refreshData();
   }, [core2, editingTask, refreshData]);
   const handleOpenNewMilestone = useCallback(() => {
     setEditingMilestone(void 0);
@@ -10659,7 +11617,7 @@ const KanbanPanel = ({
                         type: "text",
                         placeholder: "Search tasks...",
                         value: searchQuery,
-                        onChange: (e) => setSearchQuery(e.target.value),
+                        onChange: (e) => handleSearchChange(e.target.value),
                         style: {
                           width: "100%",
                           padding: "8px 32px 8px 32px",
@@ -10677,7 +11635,7 @@ const KanbanPanel = ({
                     searchQuery && /* @__PURE__ */ jsx(
                       "button",
                       {
-                        onClick: () => setSearchQuery(""),
+                        onClick: handleClearSearch,
                         style: {
                           position: "absolute",
                           right: "6px",
@@ -14630,13 +15588,13 @@ function classifyCharacter(code2) {
     return 2;
   }
 }
-function resolveAll(constructs2, events2, context) {
+function resolveAll(constructs2, events2, context2) {
   const called = [];
   let index2 = -1;
   while (++index2 < constructs2.length) {
     const resolve = constructs2[index2].resolveAll;
     if (resolve && !called.includes(resolve)) {
-      events2 = resolve(events2, context);
+      events2 = resolve(events2, context2);
       called.push(resolve);
     }
   }
@@ -14647,7 +15605,7 @@ const attention = {
   resolveAll: resolveAllAttention,
   tokenize: tokenizeAttention
 };
-function resolveAllAttention(events2, context) {
+function resolveAllAttention(events2, context2) {
   let index2 = -1;
   let open;
   let group;
@@ -14662,7 +15620,7 @@ function resolveAllAttention(events2, context) {
       open = index2;
       while (open--) {
         if (events2[open][0] === "exit" && events2[open][1].type === "attentionSequence" && events2[open][1]._open && // If the markers are the same:
-        context.sliceSerialize(events2[open][1]).charCodeAt(0) === context.sliceSerialize(events2[index2][1]).charCodeAt(0)) {
+        context2.sliceSerialize(events2[open][1]).charCodeAt(0) === context2.sliceSerialize(events2[index2][1]).charCodeAt(0)) {
           if ((events2[open][1]._close || events2[index2][1]._open) && (events2[index2][1].end.offset - events2[index2][1].start.offset) % 3 && !((events2[open][1].end.offset - events2[open][1].start.offset + events2[index2][1].end.offset - events2[index2][1].start.offset) % 3)) {
             continue;
           }
@@ -14715,14 +15673,14 @@ function resolveAllAttention(events2, context) {
           };
           nextEvents = [];
           if (events2[open][1].end.offset - events2[open][1].start.offset) {
-            nextEvents = push(nextEvents, [["enter", events2[open][1], context], ["exit", events2[open][1], context]]);
+            nextEvents = push(nextEvents, [["enter", events2[open][1], context2], ["exit", events2[open][1], context2]]);
           }
-          nextEvents = push(nextEvents, [["enter", group, context], ["enter", openingSequence, context], ["exit", openingSequence, context], ["enter", text2, context]]);
-          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events2.slice(open + 1, index2), context));
-          nextEvents = push(nextEvents, [["exit", text2, context], ["enter", closingSequence, context], ["exit", closingSequence, context], ["exit", group, context]]);
+          nextEvents = push(nextEvents, [["enter", group, context2], ["enter", openingSequence, context2], ["exit", openingSequence, context2], ["enter", text2, context2]]);
+          nextEvents = push(nextEvents, resolveAll(context2.parser.constructs.insideSpan.null, events2.slice(open + 1, index2), context2));
+          nextEvents = push(nextEvents, [["exit", text2, context2], ["enter", closingSequence, context2], ["exit", closingSequence, context2], ["exit", group, context2]]);
           if (events2[index2][1].end.offset - events2[index2][1].start.offset) {
             offset = 2;
-            nextEvents = push(nextEvents, [["enter", events2[index2][1], context], ["exit", events2[index2][1], context]]);
+            nextEvents = push(nextEvents, [["enter", events2[index2][1], context2], ["exit", events2[index2][1], context2]]);
           } else {
             offset = 0;
           }
@@ -15645,12 +16603,12 @@ function subtokenize(eventsArray) {
 }
 function subcontent(events2, eventIndex) {
   const token = events2.get(eventIndex)[1];
-  const context = events2.get(eventIndex)[2];
+  const context2 = events2.get(eventIndex)[2];
   let startPosition = eventIndex - 1;
   const startPositions = [];
   let tokenizer = token._tokenizer;
   if (!tokenizer) {
-    tokenizer = context.parser[token.contentType](token.start);
+    tokenizer = context2.parser[token.contentType](token.start);
     if (token._contentTypeTextTrailing) {
       tokenizer._contentTypeTextTrailing = true;
     }
@@ -15670,7 +16628,7 @@ function subcontent(events2, eventIndex) {
     }
     startPositions.push(startPosition);
     if (!current._tokenizer) {
-      stream = context.sliceStream(current);
+      stream = context2.sliceStream(current);
       if (!current.next) {
         stream.push(null);
       }
@@ -16126,7 +17084,7 @@ const headingAtx = {
   resolve: resolveHeadingAtx,
   tokenize: tokenizeHeadingAtx
 };
-function resolveHeadingAtx(events2, context) {
+function resolveHeadingAtx(events2, context2) {
   let contentEnd = events2.length - 2;
   let contentStart = 3;
   let content2;
@@ -16152,7 +17110,7 @@ function resolveHeadingAtx(events2, context) {
       end: events2[contentEnd][1].end,
       contentType: "text"
     };
-    splice(events2, contentStart, contentEnd - contentStart + 1, [["enter", content2, context], ["enter", text2, context], ["exit", text2, context], ["exit", content2, context]]);
+    splice(events2, contentStart, contentEnd - contentStart + 1, [["enter", content2, context2], ["enter", text2, context2], ["exit", text2, context2], ["exit", content2, context2]]);
   }
   return events2;
 }
@@ -16988,7 +17946,7 @@ function resolveAllLabelEnd(events2) {
   }
   return events2;
 }
-function resolveToLabelEnd(events2, context) {
+function resolveToLabelEnd(events2, context2) {
   let index2 = events2.length;
   let offset = 0;
   let token;
@@ -17043,13 +18001,13 @@ function resolveToLabelEnd(events2, context) {
       ...events2[close - 2][1].start
     }
   };
-  media = [["enter", group, context], ["enter", label, context]];
+  media = [["enter", group, context2], ["enter", label, context2]];
   media = push(media, events2.slice(open + 1, open + offset + 3));
-  media = push(media, [["enter", text2, context]]);
-  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events2.slice(open + offset + 4, close - 3), context));
-  media = push(media, [["exit", text2, context], events2[close - 2], events2[close - 1], ["exit", label, context]]);
+  media = push(media, [["enter", text2, context2]]);
+  media = push(media, resolveAll(context2.parser.constructs.insideSpan.null, events2.slice(open + offset + 4, close - 3), context2));
+  media = push(media, [["exit", text2, context2], events2[close - 2], events2[close - 1], ["exit", label, context2]]);
   media = push(media, events2.slice(close + 1));
-  media = push(media, [["exit", group, context]]);
+  media = push(media, [["exit", group, context2]]);
   splice(events2, open, events2.length, media);
   return events2;
 }
@@ -17412,7 +18370,7 @@ const setextUnderline = {
   resolveTo: resolveToSetextUnderline,
   tokenize: tokenizeSetextUnderline
 };
-function resolveToSetextUnderline(events2, context) {
+function resolveToSetextUnderline(events2, context2) {
   let index2 = events2.length;
   let content2;
   let text2;
@@ -17446,15 +18404,15 @@ function resolveToSetextUnderline(events2, context) {
   };
   events2[text2][1].type = "setextHeadingText";
   if (definition2) {
-    events2.splice(text2, 0, ["enter", heading2, context]);
-    events2.splice(definition2 + 1, 0, ["exit", events2[content2][1], context]);
+    events2.splice(text2, 0, ["enter", heading2, context2]);
+    events2.splice(definition2 + 1, 0, ["exit", events2[content2][1], context2]);
     events2[content2][1].end = {
       ...events2[definition2][1].end
     };
   } else {
     events2[content2][1] = heading2;
   }
-  events2.push(["exit", heading2, context]);
+  events2.push(["exit", heading2, context2]);
   return events2;
 }
 function tokenizeSetextUnderline(effects, ok2, nok) {
@@ -17588,7 +18546,7 @@ function initializeFactory(field) {
 }
 function createResolver(extraResolver) {
   return resolveAllText;
-  function resolveAllText(events2, context) {
+  function resolveAllText(events2, context2) {
     let index2 = -1;
     let enter;
     while (++index2 <= events2.length) {
@@ -17606,15 +18564,15 @@ function createResolver(extraResolver) {
         enter = void 0;
       }
     }
-    return extraResolver ? extraResolver(events2, context) : events2;
+    return extraResolver ? extraResolver(events2, context2) : events2;
   }
 }
-function resolveAllLineSuffixes(events2, context) {
+function resolveAllLineSuffixes(events2, context2) {
   let eventIndex = 0;
   while (++eventIndex <= events2.length) {
     if ((eventIndex === events2.length || events2[eventIndex][1].type === "lineEnding") && events2[eventIndex - 1][1].type === "data") {
       const data = events2[eventIndex - 1][1];
-      const chunks = context.sliceStream(data);
+      const chunks = context2.sliceStream(data);
       let index2 = chunks.length;
       let bufferIndex = -1;
       let size = 0;
@@ -17638,7 +18596,7 @@ function resolveAllLineSuffixes(events2, context) {
           break;
         }
       }
-      if (context._contentTypeTextTrailing && eventIndex === events2.length) {
+      if (context2._contentTypeTextTrailing && eventIndex === events2.length) {
         size = 0;
       }
       if (size) {
@@ -17661,7 +18619,7 @@ function resolveAllLineSuffixes(events2, context) {
         if (data.start.offset === data.end.offset) {
           Object.assign(data, token);
         } else {
-          events2.splice(eventIndex, 0, ["enter", token, context], ["exit", token, context]);
+          events2.splice(eventIndex, 0, ["enter", token, context2], ["exit", token, context2]);
           eventIndex += 2;
         }
       }
@@ -17765,7 +18723,7 @@ function createTokenizer(parser, initialize, from) {
       interrupt: true
     })
   };
-  const context = {
+  const context2 = {
     code: null,
     containerState: {},
     defineSkip,
@@ -17777,11 +18735,11 @@ function createTokenizer(parser, initialize, from) {
     sliceStream,
     write
   };
-  let state = initialize.tokenize.call(context, effects);
+  let state = initialize.tokenize.call(context2, effects);
   if (initialize.resolveAll) {
     resolveAllConstructs.push(initialize);
   }
-  return context;
+  return context2;
   function write(slice) {
     chunks = push(chunks, slice);
     main();
@@ -17789,8 +18747,8 @@ function createTokenizer(parser, initialize, from) {
       return [];
     }
     addResult(initialize, 0);
-    context.events = resolveAll(resolveAllConstructs, context.events, context);
-    return context.events;
+    context2.events = resolveAll(resolveAllConstructs, context2.events, context2);
+    return context2.events;
   }
   function sliceSerialize(token, expandTabs) {
     return serializeChunks(sliceStream(token), expandTabs);
@@ -17860,20 +18818,20 @@ function createTokenizer(parser, initialize, from) {
         point2._index++;
       }
     }
-    context.previous = code2;
+    context2.previous = code2;
   }
   function enter(type, fields) {
     const token = fields || {};
     token.type = type;
     token.start = now();
-    context.events.push(["enter", token, context]);
+    context2.events.push(["enter", token, context2]);
     stack.push(token);
     return token;
   }
   function exit2(type) {
     const token = stack.pop();
     token.end = now();
-    context.events.push(["exit", token, context]);
+    context2.events.push(["exit", token, context2]);
     return token;
   }
   function onsuccessfulconstruct(construct, info) {
@@ -17927,16 +18885,16 @@ function createTokenizer(parser, initialize, from) {
           info = store();
           currentConstruct = construct;
           if (!construct.partial) {
-            context.currentConstruct = construct;
+            context2.currentConstruct = construct;
           }
-          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {
+          if (construct.name && context2.parser.constructs.disable.null.includes(construct.name)) {
             return nok();
           }
           return construct.tokenize.call(
             // If we do have fields, create an object w/ `context` as its
             // prototype.
             // This allows a “live binding”, which is needed for `interrupt`.
-            fields ? Object.assign(Object.create(context), fields) : context,
+            fields ? Object.assign(Object.create(context2), fields) : context2,
             effects,
             ok2,
             nok
@@ -17961,17 +18919,17 @@ function createTokenizer(parser, initialize, from) {
       resolveAllConstructs.push(construct);
     }
     if (construct.resolve) {
-      splice(context.events, from2, context.events.length - from2, construct.resolve(context.events.slice(from2), context));
+      splice(context2.events, from2, context2.events.length - from2, construct.resolve(context2.events.slice(from2), context2));
     }
     if (construct.resolveTo) {
-      context.events = construct.resolveTo(context.events, context);
+      context2.events = construct.resolveTo(context2.events, context2);
     }
   }
   function store() {
     const startPoint = now();
-    const startPrevious = context.previous;
-    const startCurrentConstruct = context.currentConstruct;
-    const startEventsIndex = context.events.length;
+    const startPrevious = context2.previous;
+    const startCurrentConstruct = context2.currentConstruct;
+    const startEventsIndex = context2.events.length;
     const startStack = Array.from(stack);
     return {
       from: startEventsIndex,
@@ -17979,9 +18937,9 @@ function createTokenizer(parser, initialize, from) {
     };
     function restore() {
       point2 = startPoint;
-      context.previous = startPrevious;
-      context.currentConstruct = startCurrentConstruct;
-      context.events.length = startEventsIndex;
+      context2.previous = startPrevious;
+      context2.currentConstruct = startCurrentConstruct;
+      context2.events.length = startEventsIndex;
       stack = startStack;
       accountForPotentialSkip();
     }
@@ -18294,7 +19252,7 @@ function compiler(options) {
       type: "root",
       children: []
     };
-    const context = {
+    const context2 = {
       stack: [tree],
       tokenStack: [],
       config,
@@ -18322,13 +19280,13 @@ function compiler(options) {
       if (own$6.call(handler, events2[index2][1].type)) {
         handler[events2[index2][1].type].call(Object.assign({
           sliceSerialize: events2[index2][2].sliceSerialize
-        }, context), events2[index2][1]);
+        }, context2), events2[index2][1]);
       }
     }
-    if (context.tokenStack.length > 0) {
-      const tail = context.tokenStack[context.tokenStack.length - 1];
+    if (context2.tokenStack.length > 0) {
+      const tail = context2.tokenStack[context2.tokenStack.length - 1];
       const handler = tail[1] || defaultOnError;
-      handler.call(context, void 0, tail[0]);
+      handler.call(context2, void 0, tail[0]);
     }
     tree.position = {
       start: point$1(events2.length > 0 ? events2[0][1].start : {
@@ -18580,14 +19538,14 @@ function compiler(options) {
     tail.position.end = point$1(token.end);
   }
   function onexitlineending(token) {
-    const context = this.stack[this.stack.length - 1];
+    const context2 = this.stack[this.stack.length - 1];
     if (this.data.atHardBreak) {
-      const tail = context.children[context.children.length - 1];
+      const tail = context2.children[context2.children.length - 1];
       tail.position.end = point$1(token.end);
       this.data.atHardBreak = void 0;
       return;
     }
-    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {
+    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context2.type)) {
       onenterdata.call(this, token);
       onexitdata.call(this, token);
     }
@@ -35856,10 +36814,10 @@ function requireCore() {
     endMultiClass(mode);
   }
   function compileLanguage(language2) {
-    function langRe(value, global) {
+    function langRe(value, global2) {
       return new RegExp(
         source2(value),
-        "m" + (language2.case_insensitive ? "i" : "") + (language2.unicodeRegex ? "u" : "") + (global ? "g" : "")
+        "m" + (language2.case_insensitive ? "i" : "") + (language2.unicodeRegex ? "u" : "") + (global2 ? "g" : "")
       );
     }
     class MultiRegex {
@@ -36120,13 +37078,13 @@ function requireCore() {
       if (ignoreIllegals === void 0) {
         ignoreIllegals = true;
       }
-      const context = {
+      const context2 = {
         code: code2,
         language: languageName
       };
-      fire("before:highlight", context);
-      const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals);
-      result.code = context.code;
+      fire("before:highlight", context2);
+      const result = context2.result ? context2.result : _highlight(context2.language, context2.code, ignoreIllegals);
+      result.code = context2.code;
       fire("after:highlight", result);
       return result;
     }
@@ -47869,7 +48827,7 @@ function tokenizePotentialGfmFootnoteCall(effects, ok2, nok) {
     return ok2(code2);
   }
 }
-function resolveToPotentialGfmFootnoteCall(events2, context) {
+function resolveToPotentialGfmFootnoteCall(events2, context2) {
   let index2 = events2.length;
   while (index2--) {
     if (events2[index2][1].type === "labelImage" && events2[index2][0] === "enter") {
@@ -47907,22 +48865,22 @@ function resolveToPotentialGfmFootnoteCall(events2, context) {
     // Take the `labelImageMarker` (now `data`, the `!`)
     events2[index2 + 1],
     events2[index2 + 2],
-    ["enter", call, context],
+    ["enter", call, context2],
     // The `[`
     events2[index2 + 3],
     events2[index2 + 4],
     // The `^`.
-    ["enter", marker, context],
-    ["exit", marker, context],
+    ["enter", marker, context2],
+    ["exit", marker, context2],
     // Everything in between.
-    ["enter", string2, context],
-    ["enter", chunk, context],
-    ["exit", chunk, context],
-    ["exit", string2, context],
+    ["enter", string2, context2],
+    ["enter", chunk, context2],
+    ["exit", chunk, context2],
+    ["exit", string2, context2],
     // The ending (`]`, properly parsed and labelled).
     events2[events2.length - 2],
     events2[events2.length - 1],
-    ["exit", call, context]
+    ["exit", call, context2]
   ];
   events2.splice(index2, events2.length - index2 + 1, ...replacement);
   return events2;
@@ -48100,7 +49058,7 @@ function gfmStrikethrough(options) {
       null: [126]
     }
   };
-  function resolveAllStrikethrough(events2, context) {
+  function resolveAllStrikethrough(events2, context2) {
     let index2 = -1;
     while (++index2 < events2.length) {
       if (events2[index2][0] === "enter" && events2[index2][1].type === "strikethroughSequenceTemporary" && events2[index2][1]._close) {
@@ -48120,12 +49078,12 @@ function gfmStrikethrough(options) {
               start: Object.assign({}, events2[open][1].end),
               end: Object.assign({}, events2[index2][1].start)
             };
-            const nextEvents = [["enter", strikethrough2, context], ["enter", events2[open][1], context], ["exit", events2[open][1], context], ["enter", text2, context]];
-            const insideSpan2 = context.parser.constructs.insideSpan.null;
+            const nextEvents = [["enter", strikethrough2, context2], ["enter", events2[open][1], context2], ["exit", events2[open][1], context2], ["enter", text2, context2]];
+            const insideSpan2 = context2.parser.constructs.insideSpan.null;
             if (insideSpan2) {
-              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan2, events2.slice(open + 1, index2), context));
+              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan2, events2.slice(open + 1, index2), context2));
             }
-            splice(nextEvents, nextEvents.length, 0, [["exit", text2, context], ["enter", events2[index2][1], context], ["exit", events2[index2][1], context], ["exit", strikethrough2, context]]);
+            splice(nextEvents, nextEvents.length, 0, [["exit", text2, context2], ["enter", events2[index2][1], context2], ["exit", events2[index2][1], context2], ["exit", strikethrough2, context2]]);
             splice(events2, open - 1, index2 - open + 3, nextEvents);
             index2 = open + nextEvents.length - 2;
             break;
@@ -48498,7 +49456,7 @@ function tokenizeTable(effects, ok2, nok) {
     return bodyRowData(code2);
   }
 }
-function resolveTable(events2, context) {
+function resolveTable(events2, context2) {
   let index2 = -1;
   let inFirstCellAwaitingPipe = true;
   let rowKind = 0;
@@ -48517,7 +49475,7 @@ function resolveTable(events2, context) {
       if (token.type === "tableHead") {
         afterHeadAwaitingFirstBodyRow = false;
         if (lastTableEnd !== 0) {
-          flushTableEnd(map2, context, lastTableEnd, currentTable, currentBody);
+          flushTableEnd(map2, context2, lastTableEnd, currentTable, currentBody);
           currentBody = void 0;
           lastTableEnd = 0;
         }
@@ -48527,7 +49485,7 @@ function resolveTable(events2, context) {
           // Note: correct end is set later.
           end: Object.assign({}, token.end)
         };
-        map2.add(index2, 0, [["enter", currentTable, context]]);
+        map2.add(index2, 0, [["enter", currentTable, context2]]);
       } else if (token.type === "tableRow" || token.type === "tableDelimiterRow") {
         inFirstCellAwaitingPipe = true;
         currentCell = void 0;
@@ -48541,7 +49499,7 @@ function resolveTable(events2, context) {
             // Note: correct end is set later.
             end: Object.assign({}, token.end)
           };
-          map2.add(index2, 0, [["enter", currentBody, context]]);
+          map2.add(index2, 0, [["enter", currentBody, context2]]);
         }
         rowKind = token.type === "tableDelimiterRow" ? 2 : currentBody ? 3 : 1;
       } else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
@@ -48549,7 +49507,7 @@ function resolveTable(events2, context) {
         if (cell2[2] === 0) {
           if (lastCell[1] !== 0) {
             cell2[0] = cell2[1];
-            currentCell = flushCell(map2, context, lastCell, rowKind, void 0, currentCell);
+            currentCell = flushCell(map2, context2, lastCell, rowKind, void 0, currentCell);
             lastCell = [0, 0, 0, 0];
           }
           cell2[2] = index2;
@@ -48560,7 +49518,7 @@ function resolveTable(events2, context) {
         } else {
           if (lastCell[1] !== 0) {
             cell2[0] = cell2[1];
-            currentCell = flushCell(map2, context, lastCell, rowKind, void 0, currentCell);
+            currentCell = flushCell(map2, context2, lastCell, rowKind, void 0, currentCell);
           }
           lastCell = cell2;
           cell2 = [lastCell[1], index2, 0, 0];
@@ -48573,9 +49531,9 @@ function resolveTable(events2, context) {
       lastTableEnd = index2;
       if (lastCell[1] !== 0) {
         cell2[0] = cell2[1];
-        currentCell = flushCell(map2, context, lastCell, rowKind, index2, currentCell);
+        currentCell = flushCell(map2, context2, lastCell, rowKind, index2, currentCell);
       } else if (cell2[1] !== 0) {
-        currentCell = flushCell(map2, context, cell2, rowKind, index2, currentCell);
+        currentCell = flushCell(map2, context2, cell2, rowKind, index2, currentCell);
       }
       rowKind = 0;
     } else if (rowKind && (token.type === "data" || token.type === "tableDelimiterMarker" || token.type === "tableDelimiterFiller")) {
@@ -48583,45 +49541,45 @@ function resolveTable(events2, context) {
     }
   }
   if (lastTableEnd !== 0) {
-    flushTableEnd(map2, context, lastTableEnd, currentTable, currentBody);
+    flushTableEnd(map2, context2, lastTableEnd, currentTable, currentBody);
   }
-  map2.consume(context.events);
+  map2.consume(context2.events);
   index2 = -1;
-  while (++index2 < context.events.length) {
-    const event = context.events[index2];
+  while (++index2 < context2.events.length) {
+    const event = context2.events[index2];
     if (event[0] === "enter" && event[1].type === "table") {
-      event[1]._align = gfmTableAlign(context.events, index2);
+      event[1]._align = gfmTableAlign(context2.events, index2);
     }
   }
   return events2;
 }
-function flushCell(map2, context, range, rowKind, rowEnd, previousCell) {
+function flushCell(map2, context2, range, rowKind, rowEnd, previousCell) {
   const groupName = rowKind === 1 ? "tableHeader" : rowKind === 2 ? "tableDelimiter" : "tableData";
   const valueName = "tableContent";
   if (range[0] !== 0) {
-    previousCell.end = Object.assign({}, getPoint(context.events, range[0]));
-    map2.add(range[0], 0, [["exit", previousCell, context]]);
+    previousCell.end = Object.assign({}, getPoint(context2.events, range[0]));
+    map2.add(range[0], 0, [["exit", previousCell, context2]]);
   }
-  const now = getPoint(context.events, range[1]);
+  const now = getPoint(context2.events, range[1]);
   previousCell = {
     type: groupName,
     start: Object.assign({}, now),
     // Note: correct end is set later.
     end: Object.assign({}, now)
   };
-  map2.add(range[1], 0, [["enter", previousCell, context]]);
+  map2.add(range[1], 0, [["enter", previousCell, context2]]);
   if (range[2] !== 0) {
-    const relatedStart = getPoint(context.events, range[2]);
-    const relatedEnd = getPoint(context.events, range[3]);
+    const relatedStart = getPoint(context2.events, range[2]);
+    const relatedEnd = getPoint(context2.events, range[3]);
     const valueToken = {
       type: valueName,
       start: Object.assign({}, relatedStart),
       end: Object.assign({}, relatedEnd)
     };
-    map2.add(range[2], 0, [["enter", valueToken, context]]);
+    map2.add(range[2], 0, [["enter", valueToken, context2]]);
     if (rowKind !== 2) {
-      const start = context.events[range[2]];
-      const end = context.events[range[3]];
+      const start = context2.events[range[2]];
+      const end = context2.events[range[3]];
       start[1].end = Object.assign({}, end[1].end);
       start[1].type = "chunkText";
       start[1].contentType = "text";
@@ -48631,24 +49589,24 @@ function flushCell(map2, context, range, rowKind, rowEnd, previousCell) {
         map2.add(a, b, []);
       }
     }
-    map2.add(range[3] + 1, 0, [["exit", valueToken, context]]);
+    map2.add(range[3] + 1, 0, [["exit", valueToken, context2]]);
   }
   if (rowEnd !== void 0) {
-    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));
-    map2.add(rowEnd, 0, [["exit", previousCell, context]]);
+    previousCell.end = Object.assign({}, getPoint(context2.events, rowEnd));
+    map2.add(rowEnd, 0, [["exit", previousCell, context2]]);
     previousCell = void 0;
   }
   return previousCell;
 }
-function flushTableEnd(map2, context, index2, table2, tableBody) {
+function flushTableEnd(map2, context2, index2, table2, tableBody) {
   const exits = [];
-  const related = getPoint(context.events, index2);
+  const related = getPoint(context2.events, index2);
   if (tableBody) {
     tableBody.end = Object.assign({}, related);
-    exits.push(["exit", tableBody, context]);
+    exits.push(["exit", tableBody, context2]);
   }
   table2.end = Object.assign({}, related);
-  exits.push(["exit", table2, context]);
+  exits.push(["exit", table2, context2]);
   map2.add(index2 + 1, 0, exits);
 }
 function getPoint(events2, index2) {
@@ -48758,9 +49716,9 @@ var roundNumber = function(num, decimal) {
 var checkIsNumber = function(num, defaultValue2) {
   return defaultValue2;
 };
-var handleCallback = function(context, event, callback) {
+var handleCallback = function(context2, event, callback) {
   if (callback && typeof callback === "function") {
-    callback(context, event);
+    callback(context2, event);
   }
 };
 var easeOut = function(t) {
@@ -53684,8 +54642,8 @@ function PanelWithForwardedRef({
   tagName: Type = "div",
   ...rest
 }) {
-  const context = useContext(PanelGroupContext);
-  if (context === null) {
+  const context2 = useContext(PanelGroupContext);
+  if (context2 === null) {
     throw Error(`Panel components must be rendered within a PanelGroup container`);
   }
   const {
@@ -53699,7 +54657,7 @@ function PanelWithForwardedRef({
     registerPanel,
     resizePanel: resizePanel2,
     unregisterPanel
-  } = context;
+  } = context2;
   const panelId = useUniqueId(idFromProps);
   const panelDataRef = useRef({
     callbacks: {
@@ -55163,7 +56121,7 @@ function PanelGroupWithForwardedRef({
       forceUpdate();
     }
   }, [forceUpdate]);
-  const context = useMemo(() => ({
+  const context2 = useMemo(() => ({
     collapsePanel,
     direction,
     dragState,
@@ -55190,7 +56148,7 @@ function PanelGroupWithForwardedRef({
     width: "100%"
   };
   return createElement(PanelGroupContext.Provider, {
-    value: context
+    value: context2
   }, createElement(Type, {
     ...rest,
     children: children2,
@@ -55479,7 +56437,7 @@ const StatusBadge = ({ status }) => {
     }
   );
 };
-const TaskDetailPanel = ({ context, actions, events: events2, config }) => {
+const TaskDetailPanel = ({ context: context2, events: events2, config }) => {
   var _a;
   const { theme: theme2 } = useTheme();
   const [selectedTask, setSelectedTask] = useState(null);
@@ -55496,7 +56454,7 @@ const TaskDetailPanel = ({ context, actions, events: events2, config }) => {
       return (_a2 = panelRef.current) == null ? void 0 : _a2.focus();
     }
   );
-  const repoCapabilities = context.getRepositorySlice("repoCapabilities");
+  const repoCapabilities = context2.getRepositorySlice("repoCapabilities");
   const hasClaudeWorkflow = ((_a = repoCapabilities == null ? void 0 : repoCapabilities.data) == null ? void 0 : _a.hasClaudeWorkflow) ?? false;
   const handleAssignToClaude = useCallback(() => {
     if (!events2 || !selectedTask) return;
@@ -56364,11 +57322,11 @@ const panels = [
     },
     component: KanbanPanel,
     // Optional: Called when this specific panel is mounted
-    onMount: async (context) => {
+    onMount: async (context2) => {
       var _a;
       console.log(
         "Kanban Panel mounted",
-        (_a = context.currentScope.repository) == null ? void 0 : _a.path
+        (_a = context2.currentScope.repository) == null ? void 0 : _a.path
       );
     },
     // Optional: Called when this specific panel is unmounted
@@ -56389,11 +57347,11 @@ const panels = [
     },
     component: TaskDetailPanel,
     // Optional: Called when this specific panel is mounted
-    onMount: async (context) => {
+    onMount: async (context2) => {
       var _a;
       console.log(
         "Task Detail Panel mounted",
-        (_a = context.currentScope.repository) == null ? void 0 : _a.path
+        (_a = context2.currentScope.repository) == null ? void 0 : _a.path
       );
     },
     // Optional: Called when this specific panel is unmounted