@superblocksteam/library 2.0.0-next.38 → 2.0.0-next.39

package/dist/{index--MyJLg0V.js → index-DAxw-Mz5.js}

@@ -2690,14 +2690,14 @@ function getLoaderFn$1(options) {
           if (!(loader === "all")) return [3, 3];
           return [4, import(
             /* webpackChunkName: "blueprint-icons-all-paths-loader" */
-            "./allPathsLoader-BWLDGMsQ.js"
+            "./allPathsLoader-ECeH1kwp.js"
           )];
         case 2:
           return [2, _b2.sent().allPathsLoader];
         case 3:
           return [4, import(
             /* webpackChunkName: "blueprint-icons-split-paths-by-size-loader" */
-            "./splitPathsBySizeLoader-2qHY2dmp.js"
+            "./splitPathsBySizeLoader-ClT0eYSZ.js"
           )];
         case 4:
           return [2, _b2.sent().splitPathsBySizeLoader];
@@ -45785,6 +45785,240 @@ const SUPERBLOCKS_AUTHORIZATION_HEADER = "x-superblocks-authorization";
   akeylesssecretsmanager: srcExports.SecretsV1.Store,
   couchbase: srcExports.CouchbasePluginV1.Plugin
 });
+var TMP_HTTP_STATUS_CODE = "http.status_code";
+var TMP_HTTP_ROUTE = "http.route";
+var TMP_MESSAGING_SYSTEM = "messaging.system";
+var TMP_MESSAGING_DESTINATION_KIND = "messaging.destination_kind";
+var SEMATTRS_HTTP_STATUS_CODE = TMP_HTTP_STATUS_CODE;
+var SEMATTRS_HTTP_ROUTE = TMP_HTTP_ROUTE;
+var SEMATTRS_MESSAGING_SYSTEM = TMP_MESSAGING_SYSTEM;
+var SEMATTRS_MESSAGING_DESTINATION_KIND = TMP_MESSAGING_DESTINATION_KIND;
+const OBS_TAG_API_ID = "api-id";
+const OBS_TAG_HTTP_ROUTE = SEMATTRS_HTTP_ROUTE;
+const OBS_TAG_HTTP_STATUS_CODE = SEMATTRS_HTTP_STATUS_CODE;
+const OBS_TAG_APPLICATION_ID = "application-id";
+const OBS_TAG_BRANCH = "branch";
+const OBS_TAG_COMMIT_ID = "commit-id";
+const OBS_SOCKET_STATUS_CODE = "socket.status-code";
+class SocketErrorException extends Error {
+  constructor(code3, message2) {
+    super(message2);
+    this.code = code3;
+    this.message = message2;
+  }
+}
+class ISocket {
+  constructor(ws2, requestHandlers, globalMiddlewares, timeouts, logger) {
+    this.responseHandler = /* @__PURE__ */ new Map();
+    this.ws = ws2;
+    this.requestHandlers = requestHandlers;
+    this.globalMiddlewares = globalMiddlewares;
+    this.nxtRequestId = 0;
+    this.logger = logger ?? { error: console.error };
+    this.timeouts = timeouts;
+    this.resetConnectionTimeout();
+    this.ws.addEventListener("message", async (event) => {
+      const eventData = JSON.parse(event.data.toString());
+      return this.handleMessage(eventData);
+    });
+  }
+  async handleMessage(message2) {
+    this.resetConnectionTimeout();
+    if (message2.request) {
+      const parts = message2.request.method.split(".");
+      let handlers = this.requestHandlers;
+      for (const part of parts) {
+        handlers = handlers[part];
+        if (!handlers) {
+          return this.respondError(message2.request.id, {
+            code: 2,
+            message: `unknown method ${message2.request.method}`
+          });
+        }
+      }
+      if (!Array.isArray(handlers)) {
+        return this.respondError(message2.request.id, {
+          code: 2,
+          message: "unknown method"
+        });
+      }
+      handlers = [...this.globalMiddlewares, ...handlers];
+      if (message2.request.setAuthorization) {
+        this.peerAuthorization = message2.request.setAuthorization;
+      }
+      const reqCtx = {
+        peerAuthorization: this.peerAuthorization,
+        method: message2.request.method,
+        requestId: message2.request.id
+      };
+      const client2 = createISocketClient(this);
+      const payload = message2.request.payload;
+      let alreadyResponded = false;
+      const generateNextFn = (idx) => {
+        let wasCalled = false;
+        return async () => {
+          if (alreadyResponded) {
+            throw new SocketErrorException(4, "next() was called after the response was sent");
+          }
+          const handler = handlers[idx];
+          if (!handler) {
+            throw new SocketErrorException(5, "cannot call past the last handler in the chain");
+          }
+          if (wasCalled) {
+            throw new SocketErrorException(6, "next() was called multiple times");
+          }
+          wasCalled = true;
+          return this.callHandler(handler, payload, reqCtx, client2, generateNextFn(idx + 1));
+        };
+      };
+      let response;
+      try {
+        response = await generateNextFn(0)();
+      } catch (error) {
+        const socketError = error instanceof SocketErrorException ? { code: error.code, message: error.message } : { code: 3, message: error.toString() };
+        return this.respondError(message2.request.id, socketError, error);
+      }
+      this.respond(message2.request.id, response);
+      alreadyResponded = true;
+    } else if (message2.response && message2.response.id) {
+      const responseHandler = this.responseHandler.get(message2.response.id);
+      if (!responseHandler) {
+        return;
+      }
+      if (message2.response.error) {
+        responseHandler.reject(message2.response.error);
+      }
+      responseHandler.resolve(message2.response.payload);
+      clearTimeout(responseHandler.timeout);
+      this.responseHandler.delete(message2.response.id);
+    } else {
+      return this.respondError(-1, {
+        code: 3,
+        message: "unknown request id"
+      });
+    }
+  }
+  async callHandler(handler, params, ctx, client2, next2) {
+    return handler(params, ctx, client2, next2);
+  }
+  request(method4, params, authorization) {
+    return new Promise((resolve, reject) => {
+      const requestId = ++this.nxtRequestId;
+      this.responseHandler.set(requestId, {
+        resolve: (result) => resolve(result),
+        reject: (error) => reject(error)
+      });
+      let toSend = { request: { method: method4, payload: params, id: requestId, setAuthorization: authorization } };
+      toSend = this.decorateToSend(toSend);
+      this.ws.send(JSON.stringify(toSend));
+      this.resetConnectionTimeout();
+      this.resetNoResponseTimeout(requestId);
+    });
+  }
+  decorateToSend(message2) {
+    return message2;
+  }
+  respond(requestId, result) {
+    const toSend = {
+      response: {
+        payload: result,
+        id: requestId,
+        error: null
+      }
+    };
+    return this.ws.send(JSON.stringify(toSend));
+  }
+  respondError(requestId, error, exception) {
+    const toSend = {
+      response: {
+        payload: null,
+        id: requestId,
+        error
+      }
+    };
+    return this.ws.send(JSON.stringify(toSend));
+  }
+  resetConnectionTimeout() {
+    var _a2, _b2;
+    if (!((_a2 = this.timeouts) == null ? void 0 : _a2.connectionTimeoutInSeconds)) {
+      return;
+    }
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+    }
+    this.connectionTimeout = setTimeout(this.handleConnectionTimeout(), ((_b2 = this.timeouts) == null ? void 0 : _b2.connectionTimeoutInSeconds) * 1e3);
+  }
+  handleConnectionTimeout() {
+    return () => {
+      var _a2;
+      this.logger.error(`Connection timed out after ${(_a2 = this.timeouts) == null ? void 0 : _a2.connectionTimeoutInSeconds} seconds`);
+      this.close();
+    };
+  }
+  resetNoResponseTimeout(requestId) {
+    var _a2, _b2;
+    if (!((_a2 = this.timeouts) == null ? void 0 : _a2.noResponseTimeoutInSeconds)) {
+      return;
+    }
+    const responseHandler = this.responseHandler.get(requestId);
+    if (!responseHandler) {
+      return;
+    }
+    const noResponseTimeout = responseHandler.timeout;
+    const reject = responseHandler.reject;
+    if (responseHandler.timeout) {
+      clearTimeout(noResponseTimeout);
+    }
+    responseHandler.timeout = setTimeout(this.handleNoResponseTimeout(reject), ((_b2 = this.timeouts) == null ? void 0 : _b2.noResponseTimeoutInSeconds) * 1e3);
+  }
+  handleNoResponseTimeout(reject) {
+    return () => {
+      var _a2;
+      const message2 = `Request timed out after ${(_a2 = this.timeouts) == null ? void 0 : _a2.noResponseTimeoutInSeconds} seconds`;
+      this.logger.error(message2);
+      reject({ code: 7, message: message2 });
+    };
+  }
+  close() {
+    clearTimeout(this.connectionTimeout);
+    this.responseHandler.forEach((handler, key2) => {
+      clearTimeout(handler.timeout);
+      this.logger.error(`Rejecting pending requestId ${key2} due to connection close`);
+      handler.reject({ code: 8, message: "Connection closed" });
+    });
+    this.ws.close();
+  }
+}
+const proxyTarget = Object.freeze(() => {
+});
+function createIsocketProxy(socket, path2) {
+  return new Proxy(proxyTarget, {
+    get(_target, prop) {
+      const childPath = path2 ? `${path2}.${prop}` : prop;
+      if (childPath === "then") {
+        return void 0;
+      }
+      return createIsocketProxy(socket, childPath);
+    },
+    apply(_target, _thisArg, args) {
+      if (path2 === void 0) {
+        throw new Error("The root object is not callable");
+      }
+      if (path2.endsWith(".apply") && args.length === 2 && Array.isArray(args[1])) {
+        path2 = path2.slice(0, -".apply".length);
+        args = args[1];
+      }
+      return socket.request(path2, args[0]);
+    }
+  });
+}
+function createISocketClient(socket) {
+  return {
+    close: () => socket.close(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    call: createIsocketProxy(socket, void 0)
+  };
+}
 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$2 = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
@@ -46029,7 +46263,7 @@ var __spreadArray$3 = function(to2, from2, pack) {
   }
   return to2.concat(ar2 || Array.prototype.slice.call(from2));
 };
-var API_NAME$2 = "diag";
+var API_NAME$3 = "diag";
 var DiagAPI = (
   /** @class */
   function() {
@@ -46073,7 +46307,7 @@ var DiagAPI = (
       };
       self2.setLogger = setLogger;
       self2.disable = function() {
-        unregisterGlobal(API_NAME$2, self2);
+        unregisterGlobal(API_NAME$3, self2);
       };
       self2.createComponentLogger = function(options) {
         return new DiagComponentLogger(options);
@@ -46314,7 +46548,7 @@ var __spreadArray$1 = function(to2, from2, pack) {
   }
   return to2.concat(ar2 || Array.prototype.slice.call(from2));
 };
-var API_NAME$1 = "context";
+var API_NAME$2 = "context";
 var NOOP_CONTEXT_MANAGER = new NoopContextManager();
 var ContextAPI = (
   /** @class */
@@ -46328,7 +46562,7 @@ var ContextAPI = (
       return this._instance;
     };
     ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
-      return registerGlobal(API_NAME$1, contextManager, DiagAPI.instance());
+      return registerGlobal(API_NAME$2, contextManager, DiagAPI.instance());
     };
     ContextAPI2.prototype.active = function() {
       return this._getContextManager().active();
@@ -46345,15 +46579,232 @@ var ContextAPI = (
       return this._getContextManager().bind(context2, target);
     };
     ContextAPI2.prototype._getContextManager = function() {
-      return getGlobal$1(API_NAME$1) || NOOP_CONTEXT_MANAGER;
+      return getGlobal$1(API_NAME$2) || NOOP_CONTEXT_MANAGER;
     };
     ContextAPI2.prototype.disable = function() {
       this._getContextManager().disable();
-      unregisterGlobal(API_NAME$1, DiagAPI.instance());
+      unregisterGlobal(API_NAME$2, 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() {
+  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 _a2;
+  return (_a2 = getSpan(context2)) === null || _a2 === void 0 ? void 0 : _a2.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(name, 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(name, arg2, arg3, arg4) {
+      var opts;
+      var ctx;
+      var fn3;
+      if (arguments.length < 2) {
+        return;
+      } else if (arguments.length === 2) {
+        fn3 = arg2;
+      } else if (arguments.length === 3) {
+        opts = arg2;
+        fn3 = arg3;
+      } else {
+        opts = arg2;
+        ctx = arg3;
+        fn3 = arg4;
+      }
+      var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+      var span = this.startSpan(name, opts, parentContext);
+      var contextWithSpanSet = setSpan(parentContext, span);
+      return contextApi.with(contextWithSpanSet, fn3, 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, name, version2, options) {
+      this._provider = _provider;
+      this.name = name;
+      this.version = version2;
+      this.options = options;
+    }
+    ProxyTracer2.prototype.startSpan = function(name, options, context2) {
+      return this._getTracer().startSpan(name, 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(name, version2, options) {
+      var _a2;
+      return (_a2 = this.getDelegateTracer(name, version2, options)) !== null && _a2 !== void 0 ? _a2 : new ProxyTracer(this, name, version2, options);
+    };
+    ProxyTracerProvider2.prototype.getDelegate = function() {
+      var _a2;
+      return (_a2 = this._delegate) !== null && _a2 !== void 0 ? _a2 : NOOP_TRACER_PROVIDER;
+    };
+    ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
+      this._delegate = delegate;
+    };
+    ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version2, options) {
+      var _a2;
+      return (_a2 = this._delegate) === null || _a2 === void 0 ? void 0 : _a2.getTracer(name, version2, options);
+    };
+    return ProxyTracerProvider2;
+  }()
+);
+var SpanKind;
+(function(SpanKind2) {
+  SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+  SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+  SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+  SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+  SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+})(SpanKind || (SpanKind = {}));
+var SpanStatusCode;
+(function(SpanStatusCode2) {
+  SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+  SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+  SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
 var context$2 = ContextAPI.getInstance();
 var NoopTextMapPropagator = (
   /** @class */
@@ -46384,7 +46835,7 @@ function setBaggage(context2, baggage) {
 function deleteBaggage(context2) {
   return context2.deleteValue(BAGGAGE_KEY);
 }
-var API_NAME = "propagation";
+var API_NAME$1 = "propagation";
 var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
 var PropagationAPI = (
   /** @class */
@@ -46403,7 +46854,7 @@ var PropagationAPI = (
       return this._instance;
     };
     PropagationAPI2.prototype.setGlobalPropagator = function(propagator) {
-      return registerGlobal(API_NAME, propagator, DiagAPI.instance());
+      return registerGlobal(API_NAME$1, propagator, DiagAPI.instance());
     };
     PropagationAPI2.prototype.inject = function(context2, carrier, setter) {
       if (setter === void 0) {
@@ -46421,230 +46872,177 @@ var PropagationAPI = (
       return this._getGlobalPropagator().fields();
     };
     PropagationAPI2.prototype.disable = function() {
-      unregisterGlobal(API_NAME, DiagAPI.instance());
+      unregisterGlobal(API_NAME$1, DiagAPI.instance());
     };
     PropagationAPI2.prototype._getGlobalPropagator = function() {
-      return getGlobal$1(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+      return getGlobal$1(API_NAME$1) || NOOP_TEXT_MAP_PROPAGATOR;
     };
     return PropagationAPI2;
   }()
 );
 var propagation = PropagationAPI.getInstance();
-class SocketErrorException extends Error {
-  constructor(code3, message2) {
-    super(message2);
-    this.code = code3;
-    this.message = message2;
+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;
+      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$1(API_NAME) || this._proxyTracerProvider;
+    };
+    TraceAPI2.prototype.getTracer = function(name, version2) {
+      return this.getTracerProvider().getTracer(name, version2);
+    };
+    TraceAPI2.prototype.disable = function() {
+      unregisterGlobal(API_NAME, DiagAPI.instance());
+      this._proxyTracerProvider = new ProxyTracerProvider();
+    };
+    return TraceAPI2;
+  }()
+);
+var trace$1 = TraceAPI.getInstance();
+function isPromise(obj) {
+  return obj !== null && typeof obj === "object" && typeof obj.then === "function";
+}
+const endSpan = (traced, span) => {
+  try {
+    const result = traced();
+    if (isPromise(result)) {
+      return Promise.resolve(result).catch((err) => {
+        setHttpStatusFromError(span, typeof err === "string" ? new Error(err) : err);
+        throw err;
+      }).finally(() => span.end());
+    } else {
+      span.end();
+      return result;
+    }
+  } catch (error) {
+    setHttpStatusFromError(span, error);
+    span.end();
+    throw error;
   }
+};
+function setHttpStatusFromError(span, error) {
+  span.setAttribute(OBS_TAG_HTTP_STATUS_CODE, 500);
+  span.recordException(error);
+  span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
 }
-class ISocket {
-  constructor(ws2, requestHandlers, globalMiddlewares, timeouts, logger) {
-    this.responseHandler = /* @__PURE__ */ new Map();
-    this.ws = ws2;
-    this.requestHandlers = requestHandlers;
-    this.globalMiddlewares = globalMiddlewares;
-    this.nxtRequestId = 0;
-    this.logger = logger ?? { error: console.error };
-    this.timeouts = timeouts;
-    this.resetConnectionTimeout();
-    this.ws.addEventListener("message", async (event) => {
-      const eventData = JSON.parse(event.data.toString());
-      return this.handleMessage(eventData);
+class TracedSocket extends ISocket {
+  constructor(ws2, requestHandlers, globalMiddlewares, tracer, timeouts, logger) {
+    super(ws2, requestHandlers, globalMiddlewares, timeouts, logger);
+    this.activeSpanByRequestId = /* @__PURE__ */ new Map();
+    this.middlewareSpanByReqId = /* @__PURE__ */ new Map();
+    this.tracer = tracer;
+  }
+  async callHandler(handler, params, ctx, client2, next2) {
+    let currentContext = context$2.active();
+    const middleWareSpan = this.middlewareSpanByReqId.get(ctx.requestId);
+    const activeSpan = this.activeSpanByRequestId.get(ctx.requestId);
+    if (middleWareSpan) {
+      middleWareSpan.end();
+      if (activeSpan) {
+        currentContext = trace$1.setSpan(context$2.active(), activeSpan);
+      }
+    }
+    let result;
+    await context$2.with(currentContext, async () => {
+      await this.tracer.startActiveSpan(`WS HANDLER ${handler.name === "" ? ctx.method : handler.name}`, {
+        attributes: {
+          [SEMATTRS_MESSAGING_SYSTEM]: "ws",
+          [SEMATTRS_MESSAGING_DESTINATION_KIND]: "websocket"
+        },
+        kind: SpanKind.SERVER
+      }, async (span) => {
+        this.middlewareSpanByReqId.set(ctx.requestId, span);
+        result = await endSpan(() => super.callHandler(handler, params, ctx, client2, next2), span);
+        this.middlewareSpanByReqId.delete(ctx.requestId);
+      });
     });
+    return result;
   }
   async handleMessage(message2) {
-    this.resetConnectionTimeout();
     if (message2.request) {
-      const parts = message2.request.method.split(".");
-      let handlers = this.requestHandlers;
-      for (const part of parts) {
-        handlers = handlers[part];
-        if (!handlers) {
-          return this.respondError(message2.request.id, {
-            code: 2,
-            message: `unknown method ${message2.request.method}`
-          });
-        }
-      }
-      if (!Array.isArray(handlers)) {
-        return this.respondError(message2.request.id, {
-          code: 2,
-          message: "unknown method"
-        });
-      }
-      handlers = [...this.globalMiddlewares, ...handlers];
-      if (message2.request.setAuthorization) {
-        this.peerAuthorization = message2.request.setAuthorization;
-      }
-      const reqCtx = {
-        peerAuthorization: this.peerAuthorization,
-        method: message2.request.method,
-        requestId: message2.request.id
-      };
-      const client2 = createISocketClient(this);
+      const spanName = message2.request.method;
+      const requestId = message2.request.id;
       const payload = message2.request.payload;
-      let alreadyResponded = false;
-      const generateNextFn = (idx) => {
-        let wasCalled = false;
-        return async () => {
-          if (alreadyResponded) {
-            throw new SocketErrorException(4, "next() was called after the response was sent");
-          }
-          const handler = handlers[idx];
-          if (!handler) {
-            throw new SocketErrorException(5, "cannot call past the last handler in the chain");
-          }
-          if (wasCalled) {
-            throw new SocketErrorException(6, "next() was called multiple times");
-          }
-          wasCalled = true;
-          return this.callHandler(handler, payload, reqCtx, client2, generateNextFn(idx + 1));
-        };
-      };
-      let response;
-      try {
-        response = await generateNextFn(0)();
-      } catch (error) {
-        const socketError = error instanceof SocketErrorException ? { code: error.code, message: error.message } : { code: 3, message: error.toString() };
-        return this.respondError(message2.request.id, socketError, error);
-      }
-      this.respond(message2.request.id, response);
-      alreadyResponded = true;
-    } else if (message2.response && message2.response.id) {
-      const responseHandler = this.responseHandler.get(message2.response.id);
-      if (!responseHandler) {
-        return;
-      }
-      if (message2.response.error) {
-        responseHandler.reject(message2.response.error);
-      }
-      responseHandler.resolve(message2.response.payload);
-      clearTimeout(responseHandler.timeout);
-      this.responseHandler.delete(message2.response.id);
-    } else {
-      return this.respondError(-1, {
-        code: 3,
-        message: "unknown request id"
-      });
+      await context$2.with(propagation.extract(ROOT_CONTEXT, message2.request), async () => await this.tracer.startActiveSpan(`WS SERVER ${spanName}`, {
+        attributes: {
+          [SEMATTRS_MESSAGING_SYSTEM]: "ws",
+          [SEMATTRS_MESSAGING_DESTINATION_KIND]: "websocket",
+          [OBS_TAG_HTTP_ROUTE]: spanName,
+          [OBS_TAG_APPLICATION_ID]: payload == null ? void 0 : payload["applicationId"],
+          [OBS_TAG_API_ID]: payload == null ? void 0 : payload["apiId"],
+          [OBS_TAG_BRANCH]: (payload == null ? void 0 : payload["branch"]) ?? (payload == null ? void 0 : payload["branchName"]),
+          [OBS_TAG_COMMIT_ID]: payload == null ? void 0 : payload["commitId"]
+        },
+        kind: SpanKind.SERVER
+      }, async (span) => {
+        this.lastActiveSpan = span;
+        this.activeSpanByRequestId.set(requestId, span);
+        const result = await endSpan(() => super.handleMessage(message2), span);
+        this.activeSpanByRequestId.delete(requestId);
+        return result;
+      }));
+    } else if (message2.response) {
+      this.addEvent("ws.received-response", { ["ws.response.id"]: message2.response.id });
+      return await super.handleMessage(message2);
     }
   }
-  async callHandler(handler, params, ctx, client2, next2) {
-    return handler(params, ctx, client2, next2);
-  }
   request(method4, params, authorization) {
-    return new Promise((resolve, reject) => {
-      const requestId = ++this.nxtRequestId;
-      this.responseHandler.set(requestId, {
-        resolve: (result) => resolve(result),
-        reject: (error) => reject(error)
-      });
-      const toSend = { request: { method: method4, payload: params, id: requestId, setAuthorization: authorization } };
-      propagation.inject(context$2.active(), toSend.request);
-      this.ws.send(JSON.stringify(toSend));
-      this.resetConnectionTimeout();
-      this.resetNoResponseTimeout(requestId);
-    });
+    this.addEvent("ws.send-request", { ["ws.request.method"]: method4, ["ws.request.id"]: this.nxtRequestId });
+    return super.request(method4, params, authorization);
+  }
+  decorateToSend(message2) {
+    propagation.inject(context$2.active(), message2.request);
+    return message2;
   }
   respond(requestId, result) {
-    const toSend = {
-      response: {
-        payload: result,
-        id: requestId,
-        error: null
-      }
-    };
-    return this.ws.send(JSON.stringify(toSend));
+    this.addEvent("ws.send-response", { ["ws.response.id"]: requestId });
+    return super.respond(requestId, result);
   }
   respondError(requestId, error, exception) {
-    const toSend = {
-      response: {
-        payload: null,
-        id: requestId,
-        error
-      }
-    };
-    return this.ws.send(JSON.stringify(toSend));
-  }
-  resetConnectionTimeout() {
-    var _a2, _b2;
-    if (!((_a2 = this.timeouts) == null ? void 0 : _a2.connectionTimeoutInSeconds)) {
-      return;
-    }
-    if (this.connectionTimeout) {
-      clearTimeout(this.connectionTimeout);
+    this.addEvent("ws.send-error", { ["ws.response.id"]: requestId });
+    if (this.lastActiveSpan) {
+      setHttpStatusFromError(this.lastActiveSpan, exception ?? new Error(error.message));
+      this.lastActiveSpan.setAttribute(OBS_SOCKET_STATUS_CODE, error.code);
     }
-    this.connectionTimeout = setTimeout(this.handleConnectionTimeout(), ((_b2 = this.timeouts) == null ? void 0 : _b2.connectionTimeoutInSeconds) * 1e3);
-  }
-  handleConnectionTimeout() {
-    return () => {
-      var _a2;
-      this.logger.error(`Connection timed out after ${(_a2 = this.timeouts) == null ? void 0 : _a2.connectionTimeoutInSeconds} seconds`);
-      this.close();
-    };
+    return super.respondError(requestId, error, exception);
   }
-  resetNoResponseTimeout(requestId) {
-    var _a2, _b2;
-    if (!((_a2 = this.timeouts) == null ? void 0 : _a2.noResponseTimeoutInSeconds)) {
-      return;
-    }
-    const responseHandler = this.responseHandler.get(requestId);
-    if (!responseHandler) {
-      return;
+  addEvent(eventName, attributes2) {
+    if (this.lastActiveSpan) {
+      this.lastActiveSpan.addEvent(eventName, attributes2, /* @__PURE__ */ new Date());
     }
-    const noResponseTimeout = responseHandler.timeout;
-    const reject = responseHandler.reject;
-    if (responseHandler.timeout) {
-      clearTimeout(noResponseTimeout);
-    }
-    responseHandler.timeout = setTimeout(this.handleNoResponseTimeout(reject), ((_b2 = this.timeouts) == null ? void 0 : _b2.noResponseTimeoutInSeconds) * 1e3);
-  }
-  handleNoResponseTimeout(reject) {
-    return () => {
-      var _a2;
-      const message2 = `Request timed out after ${(_a2 = this.timeouts) == null ? void 0 : _a2.noResponseTimeoutInSeconds} seconds`;
-      this.logger.error(message2);
-      reject({ code: 7, message: message2 });
-    };
   }
   close() {
-    clearTimeout(this.connectionTimeout);
-    this.responseHandler.forEach((handler, key2) => {
-      clearTimeout(handler.timeout);
-      this.logger.error(`Rejecting pending requestId ${key2} due to connection close`);
-      handler.reject({ code: 8, message: "Connection closed" });
-    });
-    this.ws.close();
-  }
-}
-const proxyTarget = Object.freeze(() => {
-});
-function createIsocketProxy(socket, path2) {
-  return new Proxy(proxyTarget, {
-    get(_target, prop) {
-      const childPath = path2 ? `${path2}.${prop}` : prop;
-      if (childPath === "then") {
-        return void 0;
-      }
-      return createIsocketProxy(socket, childPath);
-    },
-    apply(_target, _thisArg, args) {
-      if (path2 === void 0) {
-        throw new Error("The root object is not callable");
-      }
-      if (path2.endsWith(".apply") && args.length === 2 && Array.isArray(args[1])) {
-        path2 = path2.slice(0, -".apply".length);
-        args = args[1];
-      }
-      return socket.request(path2, args[0]);
+    for (const span of this.activeSpanByRequestId.values()) {
+      span.end();
     }
-  });
-}
-function createISocketClient(socket) {
-  return {
-    close: () => socket.close(),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    call: createIsocketProxy(socket, void 0)
-  };
+    this.activeSpanByRequestId = /* @__PURE__ */ new Map();
+    this.lastActiveSpan = void 0;
+    super.close();
+  }
 }
 var ws$1 = null;
 if (typeof WebSocket !== "undefined") {
@@ -46669,9 +47067,9 @@ function connectWebSocket(wsUrl, protocol) {
     });
   });
 }
-class ISocketWithClientAuth extends ISocket {
-  constructor(ws2, authorization, requestHandlers, globalMiddlewares, timeouts) {
-    super(ws2, requestHandlers, globalMiddlewares, timeouts);
+class ISocketWithClientAuth extends TracedSocket {
+  constructor(ws2, authorization, requestHandlers, globalMiddlewares, tracer, timeouts) {
+    super(ws2, requestHandlers, globalMiddlewares, tracer, timeouts);
     this.hasSentAuth = false;
     this.authorization = authorization;
   }
@@ -53585,7 +53983,7 @@ var Reaction = /* @__PURE__ */ function() {
   _proto.toString = function toString22() {
     return "Reaction[" + this.name_ + "]";
   };
-  _proto.trace = function trace$1(enterBreakPoint) {
+  _proto.trace = function trace$12(enterBreakPoint) {
     if (enterBreakPoint === void 0) {
       enterBreakPoint = false;
     }
@@ -97693,6 +98091,7 @@ async function connectSocket(serverUrl, peerId, userId) {
         ]
       },
       [],
+      trace$1.getTracer("superblocks-ui-framework"),
       {
         connectionTimeoutInSeconds: 6 * 60,
         noResponseTimeoutInSeconds: 5 * 60
@@ -144032,14 +144431,14 @@ function getLoaderFn(options) {
           if (!(loader === "all")) return [3, 3];
           return [4, import(
             /* webpackChunkName: "blueprint-icons-all-paths-loader" */
-            "./allPathsLoader-C82irE62.js"
+            "./allPathsLoader-BTLo3hEI.js"
           )];
         case 2:
           return [2, _b2.sent().allPathsLoader];
         case 3:
           return [4, import(
             /* webpackChunkName: "blueprint-icons-split-paths-by-size-loader" */
-            "./splitPathsBySizeLoader-aKrjndrG.js"
+            "./splitPathsBySizeLoader-BaVxbR-T.js"
           )];
         case 4:
           return [2, _b2.sent().splitPathsBySizeLoader];
@@ -190561,4 +190960,4 @@ export {
   copyToClipboard as y,
   navigateTo as z
 };
-//# sourceMappingURL=index--MyJLg0V.js.map
+//# sourceMappingURL=index-DAxw-Mz5.js.map