@remember-web/sse 0.1.0-alpha.1

package/dist/worker/sse.worker.js

@@ -0,0 +1,1865 @@
+function _assertClassBrand(e, t, n) {
+  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+  throw new TypeError("Private element is not present on this object");
+}
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _classPrivateFieldGet2(s, a) {
+  return s.get(_assertClassBrand(s, a));
+}
+function _classPrivateFieldSet2(s, a, r) {
+  return s.set(_assertClassBrand(s, a), r), r;
+}
+function _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: true
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(true);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = false, next;
+            return next.value = t, next.done = true, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: true
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: true
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = false, next;
+      }
+      return next.done = true, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = true;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
+          } else {
+            if (!u) throw Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+      args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(undefined);
+    });
+  };
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeFunction(fn) {
+  try {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  } catch (e) {
+    return typeof fn === "function";
+  }
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _classPrivateFieldInitSpec(obj, privateMap, value) {
+  _checkPrivateRedeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  _checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+
+// 15초는 소비자 요구가 아직 없는 임의 기본값입니다 — 티켓 대상 판별의 지연 허용치가 정해지면 조정합니다
+var PING_INTERVAL_MS = 15000;
+/**
+ * @description 탭 포트의 장부 — 등록·떠남과 ping 주기를 소유합니다.
+ *
+ * 무응답 포트를 장부에서 빼지 않습니다: frozen 탭의 메시지는 브라우저가 큐잉했다가
+ * 깨어날 때 전부 배달하므로, 계속 보내는 것이 곧 공백 없는 복구입니다 —
+ * 빼는 순간부터가 그 탭이 놓치는 구간이 됩니다.
+ * close 없이 사라진 탭(크래시·창 닫기)의 포트는 장부에 남지만 무해합니다 — 전송은 조용히
+ * 버려지고, 상한은 워커 생존 중 닫힌 탭 수이며, 마지막 클라이언트가 사라지면 브라우저가 워커째 거둡니다.
+ */
+var createPortRegistry = function createPortRegistry() {
+  var ports = new Set();
+  // 이번 주기 pong을 아직 안 낸 포트 — ping 직후에는 전원이 여기 있으므로 무응답 판정에 쓰면 안 됩니다
+  var awaitingPong = new Set();
+  // 한 주기를 통째로 놓친 포트 — frozen이거나 죽은 것. pong이 오면 되돌아옵니다
+  var silent = new Set();
+  var sendPings = function sendPings() {
+    awaitingPong.forEach(function (port) {
+      return silent.add(port);
+    });
+    ports.forEach(function (port) {
+      return awaitingPong.add(port);
+    });
+    ports.forEach(function (port) {
+      return port.postMessage({
+        kind: 'ping'
+      });
+    });
+  };
+  // 해제 수단을 두지 않습니다 — 이 타이머의 수명은 워커 수명이고, 워커는 브라우저가 통째로 거둡니다.
+  // 테스트의 가짜 타이머는 vitest.setup의 afterEach(useRealTimers)가 시계째 버려 교차 오염이 없습니다
+  setInterval(sendPings, PING_INTERVAL_MS);
+  return {
+    add: function add(port) {
+      ports.add(port);
+    },
+    /** @description 떠난 포트의 늦은 메시지를 거르는 유일한 기준 — frozen 탭은 장부에 남아 있습니다 */
+    has: function has(port) {
+      return ports.has(port);
+    },
+    /**
+     * @description 탭이 스스로 떠났습니다 — 장부에서 빼고 포트를 닫습니다.
+     * 마지막이었는지 함께 알려 호출부가 세션을 접을지 정하게 합니다.
+     */
+    close: function close(port) {
+      ports["delete"](port);
+      awaitingPong["delete"](port);
+      silent["delete"](port);
+      port.close();
+      return {
+        wasLast: ports.size === 0
+      };
+    },
+    markAlive: function markAlive(port) {
+      awaitingPong["delete"](port);
+      silent["delete"](port);
+    },
+    size: function size() {
+      return ports.size;
+    },
+    forEach: function forEach(visit) {
+      return ports.forEach(visit);
+    },
+    /**
+     * @description 티켓을 물어볼 탭 하나 — EventSource가 하나라 티켓도 한 장이면 됩니다.
+     * 전원에게 뿌리면 탭 수만큼 POST가 나가고, 그 증폭이 429(fatal)를 자초합니다.
+     * 이번 주기에 답한 탭을 먼저 고르고, 없으면 아직 판정 전인 탭에게 묻습니다.
+     * 전원이 확정 침묵이면 undefined: 답이 올 수 없는 요청을 큐에 쌓으면
+     * 깨어난 탭이 그 수만큼 한꺼번에 POST를 쏘게 됩니다.
+     */
+    livelyPort: function livelyPort() {
+      var _candidates$find;
+      var candidates = _toConsumableArray(ports);
+      return (_candidates$find = candidates.find(function (port) {
+        return !awaitingPong.has(port);
+      })) !== null && _candidates$find !== void 0 ? _candidates$find : candidates.find(function (port) {
+        return !silent.has(port);
+      });
+    }
+  };
+};
+
+/** @description 판정을 메시지 정의 옆에 둡니다 — 필드가 바뀌면 여기도 같이 눈에 띄도록 */
+var isTicketResponse = function isTicketResponse(message) {
+  if (message.kind !== 'ticket-response') {
+    return false;
+  }
+  var ok = message.ok,
+    ticket = message.ticket,
+    error = message.error;
+  if (ok === true) {
+    return typeof ticket === 'string';
+  }
+  if (ok !== false || _typeof(error) !== 'object' || error === null || Array.isArray(error)) {
+    return false;
+  }
+  // status는 fatal 판정에 쓰이므로 숫자가 아니면 재시도 대상으로 흘려보내지 않습니다
+  var status = error.status,
+    cause = error.cause;
+  if (status !== undefined && typeof status !== 'number') {
+    return false;
+  }
+  // 미지 cause 문자열은 버리지 않고 통과시킵니다 — 코어가 모르는 값은 status 규칙으로 처리하므로 배포 skew에 안전합니다
+  return cause === undefined || typeof cause === 'string';
+};
+
+var TICKET_TIMEOUT_MS = 10000;
+var TICKET_NETWORK_FAILURE = Object.freeze({
+  ok: false,
+  error: Object.freeze({})
+});
+var TICKET_AUTH_CALLBACK_FAILURE = Object.freeze({
+  ok: false,
+  error: Object.freeze({
+    cause: 'auth_callback'
+  })
+});
+var AuthTokenError = /*#__PURE__*/function (_Error) {
+  function AuthTokenError(message, options) {
+    var _this;
+    _classCallCheck(this, AuthTokenError);
+    _this = _callSuper(this, AuthTokenError, [message, options]);
+    _this.name = 'AuthTokenError';
+    return _this;
+  }
+  _inherits(AuthTokenError, _Error);
+  return _createClass(AuthTokenError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+var resolveAuthToken = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(getAuthToken) {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 3;
+          return getAuthToken();
+        case 3:
+          return _context.abrupt("return", _context.sent);
+        case 6:
+          _context.prev = 6;
+          _context.t0 = _context["catch"](0);
+          throw new AuthTokenError('getAuthToken threw', {
+            cause: _context.t0
+          });
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 6]]);
+  }));
+  return function resolveAuthToken(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var authHeaders = function authHeaders(token) {
+  return token === null ? undefined : {
+    Authorization: "Bearer ".concat(token)
+  };
+};
+var hasTicket = function hasTicket(body) {
+  if (_typeof(body) !== 'object' || body === null) {
+    return false;
+  }
+  var data = body.data;
+  return _typeof(data) === 'object' && data !== null && typeof data.ticket === 'string';
+};
+/**
+ * @description 본문을 계약({ data: { ticket: string } } — 사내 기본 응답 스키마)으로 좁혀 값으로 돌려줍니다 —
+ * 파싱 실패(게이트웨이·프록시가 200으로 주는 HTML 등)와 형태 위반(ticket 부재)을 가르지 않습니다:
+ * 어느 쪽이든 서버가 응답한 본문 계약 위반이고, 경로 생존 증거라 status를 실어 네트워크성 연속 판정을 끊습니다.
+ * 이 분기는 stalled·fatal 어느 쪽에도 닿지 않는 유일한 침묵 실패라 warn을 남깁니다 — 서버 로그에도 흔적이
+ * 없는 실패(서버 입장에선 정상 200)여서 이 로그가 유일한 단서입니다.
+ */
+var parseTicketBody = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(response, logger) {
+    var body;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return response.json()["catch"](function () {
+            return null;
+          });
+        case 2:
+          body = _context2.sent;
+          if (hasTicket(body)) {
+            _context2.next = 6;
+            break;
+          }
+          logger === null || logger === void 0 || logger.warn("sse: \uD2F0\uCF13 \uC751\uB2F5(".concat(response.status, ") \uBCF8\uBB38\uC774 \uACC4\uC57D({ data: { ticket } })\uACFC \uB2E4\uB985\uB2C8\uB2E4 \u2014 \uC7AC\uC2DC\uB3C4\uB294 \uACC4\uC18D\uD569\uB2C8\uB2E4"));
+          return _context2.abrupt("return", {
+            ok: false,
+            error: {
+              status: response.status
+            }
+          });
+        case 6:
+          return _context2.abrupt("return", {
+            ok: true,
+            ticket: body.data.ticket
+          });
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function parseTicketBody(_x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * @description 연결 티켓을 발급합니다 — TTL 15s이므로 발급 즉시 연결해야 합니다
+ */
+var issueTicket = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(options) {
+    var _options$fetch;
+    var fetchImpl, token, response, _options$logger;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          fetchImpl = (_options$fetch = options.fetch) !== null && _options$fetch !== void 0 ? _options$fetch : globalThis.fetch;
+          _context3.prev = 1;
+          _context3.next = 4;
+          return resolveAuthToken(options.getAuthToken);
+        case 4:
+          token = _context3.sent;
+          _context3.next = 7;
+          return fetchImpl("".concat(options.baseUrl, "/v1/events/ticket"), {
+            method: 'POST',
+            headers: authHeaders(token)
+          });
+        case 7:
+          response = _context3.sent;
+          if (response.ok) {
+            _context3.next = 10;
+            break;
+          }
+          return _context3.abrupt("return", {
+            ok: false,
+            error: {
+              status: response.status
+            }
+          });
+        case 10:
+          _context3.next = 12;
+          return parseTicketBody(response, options.logger);
+        case 12:
+          return _context3.abrupt("return", _context3.sent);
+        case 15:
+          _context3.prev = 15;
+          _context3.t0 = _context3["catch"](1);
+          if (!(_context3.t0 instanceof AuthTokenError)) {
+            _context3.next = 20;
+            break;
+          }
+          // 정지 결정은 SseClient 몫이지만, 로그는 원인 예외가 있는 여기서 한 번만 — 워커 경로에선 탭 스코프라 유일한 기록입니다
+          (_options$logger = options.logger) === null || _options$logger === void 0 || _options$logger.error('sse: getAuthToken이 예외를 던져 멈춥니다 — 콜백은 실패 시 null을 반환해야 합니다', _context3.t0.cause);
+          return _context3.abrupt("return", TICKET_AUTH_CALLBACK_FAILURE);
+        case 20:
+          return _context3.abrupt("return", TICKET_NETWORK_FAILURE);
+        case 21:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[1, 15]]);
+  }));
+  return function issueTicket(_x4) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * @description 티켓 발급에 시간 제한을 겁니다 — 타임아웃 이후 도착한 응답은 race가 이미 완료돼 무시됩니다
+ */
+var issueTicketWithTimeout = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(options) {
+    var ticketTimer, ticketTimeout, result;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          ticketTimeout = new Promise(function (resolve) {
+            ticketTimer = setTimeout(function () {
+              return resolve(TICKET_NETWORK_FAILURE);
+            }, TICKET_TIMEOUT_MS);
+          });
+          _context4.next = 3;
+          return Promise.race([issueTicket(options), ticketTimeout]);
+        case 3:
+          result = _context4.sent;
+          clearTimeout(ticketTimer);
+          return _context4.abrupt("return", result);
+        case 6:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return function issueTicketWithTimeout(_x5) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+// 탭↔워커 postMessage 왕복 여유분 — 실측 아닌 임의값입니다
+var PORT_ROUNDTRIP_SLACK_MS = 2000;
+// 탭의 발급 제한보다 늦게 끝나야 합니다 — 탭이 스스로 실패를 알려줄 기회를 먼저 줍니다
+var TICKET_RESPONSE_TIMEOUT_MS = TICKET_TIMEOUT_MS + PORT_ROUNDTRIP_SLACK_MS;
+/**
+ * @description 티켓 발급을 탭에 위임합니다 — 토큰은 탭에 남고 워커는 발급 결과만 받습니다.
+ * 워커가 코어 연결 루프를 그대로 쓸 수 있도록, 요청·응답 왕복을 Promise 하나로 바꿉니다.
+ */
+var createTicketDelegate = function createTicketDelegate(requestFromTab) {
+  // 왕복은 한 번에 하나 — 겹친 요청은 탭에 다시 묻지 않고 이 결과를 함께 받습니다
+  var pending = null;
+  var finish = function finish(result) {
+    if (pending === null) {
+      return;
+    }
+    var _pending = pending,
+      resolvers = _pending.resolvers,
+      timer = _pending.timer;
+    pending = null;
+    clearTimeout(timer);
+    resolvers.forEach(function (resolve) {
+      return resolve(result);
+    });
+  };
+  var startNewRequest = function startNewRequest(resolve) {
+    pending = {
+      resolvers: [resolve],
+      timer: setTimeout(function () {
+        return finish(TICKET_NETWORK_FAILURE);
+      }, TICKET_RESPONSE_TIMEOUT_MS)
+    };
+    try {
+      requestFromTab();
+    } catch (_unused) {
+      finish(TICKET_NETWORK_FAILURE);
+    }
+  };
+  var joinInFlight = function joinInFlight(resolve) {
+    var _pending2;
+    (_pending2 = pending) === null || _pending2 === void 0 || _pending2.resolvers.push(resolve);
+  };
+  return {
+    request: function request() {
+      return new Promise(function (resolve) {
+        if (pending === null) {
+          startNewRequest(resolve);
+          return;
+        }
+        joinInFlight(resolve);
+      });
+    },
+    /** @description 다음 연결이 이 왕복에 합류해 응답 없이 기다리지 않게 끊습니다 */
+    cancel: function cancel() {
+      return finish(TICKET_NETWORK_FAILURE);
+    },
+    /** @description 시간 제한 뒤 도착한 응답은 pending이 비어 있어 무시됩니다 */
+    settle: function settle(message) {
+      var result = message.ok ? {
+        ok: true,
+        ticket: message.ticket
+      } : {
+        ok: false,
+        error: message.error
+      };
+      finish(result);
+    }
+  };
+};
+
+// 서버가 /v1/events 스트림으로 보내는 연결 수명주기 이벤트 — 도메인 이벤트와 달리 SDK가 소비합니다
+var SERVER_CONNECTION_EVENTS = {
+  hello: 'hello',
+  goaway: 'goaway'
+};
+/**
+ * @description SDK가 스스로 발화하는 이벤트 — 재수립(resync)·멈춘 사유(fatal)·미연결 지속(stalled)을 SDK가 알아채 알립니다
+ */
+var SDK_EVENTS = {
+  resync: 'resync',
+  fatal: 'fatal',
+  stalled: 'stalled'
+};
+/**
+ * @description 소비처로 배달하는 이름들 — 출처(서버·SDK)와 무관하게 "소비처가 보는가"만 봅니다.
+ * 워커는 구독 장부와 별개로 이 목록을 중계해야 합니다: 장부만 보고 붙이면 소비처에 영영 도달하지 않습니다.
+ * SDK 이벤트는 배달이 곧 존재 이유라 전부 파생합니다 — 나열하면 이름을 늘릴 때 빠뜨릴 자리가 생깁니다.
+ * 서버 연결 이벤트는 SDK가 소비하는 게 기본이라 배달할 것만 골라 넣습니다:
+ * goaway는 SDK가 action으로 재연결을 판단하고, 소비처는 reason으로 안내를 정합니다.
+ */
+var FORWARDED_EVENTS = [].concat(_toConsumableArray(Object.values(SDK_EVENTS)), [SERVER_CONNECTION_EVENTS.goaway]);
+// 멤버십 검사는 Set 파생으로 — Object.hasOwn(Safari 15.4+)이 배포 하한을 만들지 않게 합니다
+var SERVER_CONNECTION_EVENT_NAMES = new Set(Object.values(SERVER_CONNECTION_EVENTS));
+var FORWARDED_EVENT_NAMES = new Set(FORWARDED_EVENTS);
+var isServerConnectionEvent = function isServerConnectionEvent(type) {
+  return SERVER_CONNECTION_EVENT_NAMES.has(type);
+};
+var isForwardedEvent = function isForwardedEvent(type) {
+  return FORWARDED_EVENT_NAMES.has(type);
+};
+/**
+ * @description 서버 스트림에 구독을 걸 이름인지 판정합니다 — 연결 이벤트와 중계 목록은 SDK가 소유합니다.
+ * 목록에서 판정을 파생해야 이름을 추가할 때 구독 제외가 따라옵니다: 빠지면 워커가 같은 이벤트를 두 번 배달합니다.
+ */
+var isSubscribableEvent = function isSubscribableEvent(type) {
+  return !isServerConnectionEvent(type) && !isForwardedEvent(type);
+};
+/**
+ * @description 구독해도 배달되지 않는 이름인지 판정합니다 — 조용한 무배달 구독을 경고로 알리는 데 씁니다.
+ * 중계 목록에 있으면 SDK가 소비하더라도 소비처에 배달되므로 경고 대상이 아닙니다.
+ */
+var isUndeliverableEvent = function isUndeliverableEvent(type) {
+  return isServerConnectionEvent(type) && !isForwardedEvent(type);
+};
+
+var DEFAULT_BACKOFF = {
+  initialDelayMs: 1000,
+  maxDelayMs: 30000,
+  multiplier: 2
+};
+/** @description 지수 백오프 + full jitter — 동시 재연결 폭주(thundering herd)를 분산시킵니다 */
+var createBackoff = function createBackoff(options) {
+  var _options$initialDelay, _options$maxDelayMs, _options$multiplier;
+  var random = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Math.random;
+  var initialDelayMs = (_options$initialDelay = options === null || options === void 0 ? void 0 : options.initialDelayMs) !== null && _options$initialDelay !== void 0 ? _options$initialDelay : DEFAULT_BACKOFF.initialDelayMs;
+  var maxDelayMs = (_options$maxDelayMs = options === null || options === void 0 ? void 0 : options.maxDelayMs) !== null && _options$maxDelayMs !== void 0 ? _options$maxDelayMs : DEFAULT_BACKOFF.maxDelayMs;
+  var multiplier = (_options$multiplier = options === null || options === void 0 ? void 0 : options.multiplier) !== null && _options$multiplier !== void 0 ? _options$multiplier : DEFAULT_BACKOFF.multiplier;
+  var attempt = 0;
+  return {
+    nextDelayMs: function nextDelayMs() {
+      var capped = Math.min(maxDelayMs, initialDelayMs * Math.pow(multiplier, attempt));
+      attempt += 1;
+      return random() * capped;
+    },
+    reset: function reset() {
+      attempt = 0;
+    }
+  };
+};
+
+/**
+ * @description SseClient·WorkerSseClient가 공유하는 구독·발행 코어.
+ * 리스너 예외를 격리합니다 — 하나가 던져도 나머지 리스너와 호출자의 정리 로직이 중단되지 않게.
+ */
+var createEmitter = function createEmitter(logger) {
+  var handlers = new Map();
+  var statusListeners = new Set();
+  var safeCall = function safeCall(listener, value) {
+    try {
+      listener(value);
+    } catch (error) {
+      logger === null || logger === void 0 || logger.warn('sse: 리스너 예외를 격리했습니다', error);
+    }
+  };
+  return {
+    on: function on(type, handler) {
+      var _handlers$get;
+      var set = (_handlers$get = handlers.get(type)) !== null && _handlers$get !== void 0 ? _handlers$get : new Set();
+      set.add(handler);
+      handlers.set(type, set);
+      return function () {
+        set["delete"](handler);
+      };
+    },
+    onStatus: function onStatus(listener) {
+      statusListeners.add(listener);
+      return function () {
+        statusListeners["delete"](listener);
+      };
+    },
+    emit: function emit(type, payload) {
+      var _handlers$get2;
+      (_handlers$get2 = handlers.get(type)) === null || _handlers$get2 === void 0 || _handlers$get2.forEach(function (handler) {
+        return safeCall(handler, payload);
+      });
+    },
+    emitStatus: function emitStatus(status) {
+      statusListeners.forEach(function (listener) {
+        return safeCall(listener, status);
+      });
+    },
+    handlerTypes: function handlerTypes() {
+      return _toConsumableArray(handlers.keys());
+    }
+  };
+};
+
+/**
+ * @description 두 구현이 공유하는 구독 표면 — 구독 장부(emitter)를 소유하고 on·onStatus를 확정합니다.
+ * 연결을 어떻게 다루는지는 모릅니다: 구현마다 다른 것만 추상 멤버로 남깁니다.
+ * 같아야 할 것을 한 벌로 두기 위한 클래스입니다 — 두 구현이 각자 배선하다 갈린 이력이 있습니다.
+ */
+var BaseSseClient = /*#__PURE__*/function () {
+  function BaseSseClient(logger) {
+    _classCallCheck(this, BaseSseClient);
+    _defineProperty(this, "logger", void 0);
+    _defineProperty(this, "emitter", void 0);
+    this.logger = logger;
+    this.emitter = createEmitter(logger);
+  }
+  return _createClass(BaseSseClient, [{
+    key: "on",
+    value: function on(type, handler) {
+      if (isUndeliverableEvent(type)) {
+        var _this$logger;
+        (_this$logger = this.logger) === null || _this$logger === void 0 || _this$logger.warn("sse: '".concat(type, "'\uB294 SDK\uAC00 \uC18C\uBE44\uD558\uB294 \uC608\uC57D \uC774\uBCA4\uD2B8\uB77C \uAD6C\uB3C5\uC774 \uBC30\uB2EC\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4"));
+      }
+      this.registerSubscription(type);
+      return this.emitter.on(type, handler);
+    }
+  }, {
+    key: "onStatus",
+    value: function onStatus(listener) {
+      return this.emitter.onStatus(listener);
+    }
+    /**
+     * @description 탭이 돌아올 때 connect()를 다시 부릅니다 — 전원이 얼어붙어 접힌 연결(휴면)은
+     * 깨어난 탭의 이 호출만이 다시 세울 수 있습니다. 연결이 살아 있으면 아무 일도 없습니다.
+     * bfcache 복귀는 visibilitychange가 아니라 pageshow로만 알 수 있어 둘 다 봅니다.
+     * SSR에는 붙일 곳이 없어 아무 일도 하지 않습니다.
+     *
+     * @returns 리스너를 떼는 함수 — 클라이언트를 버릴 때 함께 부르세요
+     */
+  }, {
+    key: "attachAutoResume",
+    value: function attachAutoResume() {
+      var _this = this;
+      if (typeof document === 'undefined' || typeof window === 'undefined') {
+        return function () {};
+      }
+      // 되살릴 대상은 idle입니다 — 전원 침묵으로 접힌 휴면이 이 상태입니다(workerConnection.close).
+      // closed(소비처 disconnect·서버 goaway close)는 끊은 의도를 되살리지 않고,
+      // fatal의 회복 계약은 disconnect 후 connect라 자동 재개가 대신할 수 없습니다
+      var notifyAlive = function notifyAlive() {
+        if (_this.status === 'closed' || _this.status === 'fatal') {
+          return;
+        }
+        _this.connect();
+      };
+      var onVisible = function onVisible() {
+        if (document.visibilityState === 'visible') {
+          notifyAlive();
+        }
+      };
+      // persisted = bfcache 복귀, 직결 경로용 — Chrome은 SharedWorker 페이지를 bfcache에 넣지 않고,
+      // 넣는 브라우저라면 포트가 이미 죽어 이 connect가 닿지 않습니다(알려진 한계)
+      var onPageShow = function onPageShow(event) {
+        if (event.persisted) {
+          notifyAlive();
+        }
+      };
+      document.addEventListener('visibilitychange', onVisible);
+      window.addEventListener('pageshow', onPageShow);
+      return function () {
+        document.removeEventListener('visibilitychange', onVisible);
+        window.removeEventListener('pageshow', onPageShow);
+      };
+    }
+  }]);
+}();
+
+/**
+ * @description 재시도 대기 Promise — 타이머 만료·abort 중 먼저 발생하는 쪽에서 resolve됩니다.
+ * 어느 경로로 풀리든 타이머와 abort 리스너를 함께 정리합니다.
+ */
+var waitForRetry = function waitForRetry(delayMs, signal) {
+  return new Promise(function (resolve) {
+    var finish = function finish() {
+      clearTimeout(timer);
+      signal.removeEventListener('abort', finish);
+      resolve();
+    };
+    var timer = setTimeout(finish, delayMs);
+    signal.addEventListener('abort', finish);
+  });
+};
+
+/**
+ * @description 상태 전이 규칙을 명시합니다
+ */
+var TRANSITIONS = {
+  idle: {
+    connect: 'connecting',
+    disconnect: 'closed'
+  },
+  connecting: {
+    hello: 'open',
+    retryableFailure: 'reconnecting',
+    fatalFailure: 'fatal',
+    disconnect: 'closed'
+  },
+  open: {
+    retryableFailure: 'reconnecting',
+    fatalFailure: 'fatal',
+    disconnect: 'closed'
+  },
+  reconnecting: {
+    readyToRetry: 'connecting',
+    disconnect: 'closed'
+  },
+  // closed 후 재연결을 열어둔 이유: React StrictMode 재마운트가 같은 인스턴스로 connect→disconnect→connect를 수행합니다
+  closed: {
+    connect: 'connecting'
+  },
+  fatal: {
+    disconnect: 'closed'
+  }
+};
+/** @description 연결 상태머신 — 표에 선언된 전이만 수행하고, 전이가 일어날 때 onChange를 호출합니다 */
+var createStatusMachine = function createStatusMachine(onChange) {
+  var status = 'idle';
+  return {
+    get status() {
+      return status;
+    },
+    transition: function transition(event) {
+      var transitions = TRANSITIONS[status];
+      var next = transitions[event];
+      if (next === undefined) {
+        return false;
+      }
+      status = next;
+      onChange(next);
+      return true;
+    }
+  };
+};
+
+// 상태 이름의 단일 원천 — 타입과 런타임 멤버십 검사가 같은 목록을 봅니다
+// goaway 값의 단일 원천 — 타입과 런타임 검사가 같은 목록을 봅니다
+var GOAWAY_REASONS = ['deploy', 'user_logout', 'maintenance', 'manual'];
+var GOAWAY_ACTIONS = ['retry', 'close'];
+/**
+ * @description 포트·스트림 너머의 값을 좁힙니다 — 미지 값은 없는 것으로 봅니다
+ */
+var isGoawayReason = function isGoawayReason(value) {
+  return GOAWAY_REASONS.includes(value);
+};
+var isGoawayAction = function isGoawayAction(value) {
+  return GOAWAY_ACTIONS.includes(value);
+};
+
+var parsePayload = function parsePayload(event) {
+  if (typeof event.data !== 'string' || event.data === '') {
+    return undefined;
+  }
+  try {
+    return JSON.parse(event.data);
+  } catch (_unused) {
+    return event.data;
+  }
+};
+// 구버전 서버·잘린 프레임에서는 필드가 없거나 미지 값이 옵니다 — 아는 값만 남기고 나머지는 버립니다
+var toGoawayPayload = function toGoawayPayload(parsed) {
+  if (_typeof(parsed) !== 'object' || parsed === null) {
+    return {};
+  }
+  var reason = parsed.reason,
+    action = parsed.action;
+  return _objectSpread2(_objectSpread2({}, isGoawayReason(reason) && {
+    reason: reason
+  }), isGoawayAction(action) && {
+    action: action
+  });
+};
+/**
+ * @description 도메인 이벤트 리스너를 소스에 1회 부착합니다 — SDK 예약 이벤트는 소비처로 흘리지 않습니다
+ */
+var attachDomainListener = function attachDomainListener(source, attachedEvents, type, deliver) {
+  if (attachedEvents.has(type)) {
+    return;
+  }
+  if (!isSubscribableEvent(type)) {
+    return;
+  }
+  attachedEvents.add(type);
+  source.addEventListener(type, function (event) {
+    deliver(type, parsePayload(event));
+  });
+};
+/**
+ * @description 콜백 세계(EventSource 이벤트·타이머·abort)를 Promise 하나로 바꾸는 경계 어댑터.
+ * 아래 결말 4개 중 먼저 발생하는 것으로 정확히 한 번 끝나고, hello는 결말이 아니라 수립 신호입니다.
+ */
+var streamUntilClosed = function streamUntilClosed(source, signal, hooks) {
+  return new Promise(function (resolve) {
+    var settled = false;
+    var settle = function settle(closure, options) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(helloTimer);
+      signal.removeEventListener('abort', onAbort);
+      if (options.notifyClosed) {
+        hooks.onClosed(closure);
+      }
+      resolve(closure.outcome);
+    };
+    var helloTimer = setTimeout(function () {
+      return settle({
+        outcome: 'error'
+      }, {
+        notifyClosed: true
+      });
+    }, hooks.helloTimeoutMs);
+    source.addEventListener(SERVER_CONNECTION_EVENTS.goaway, function (event) {
+      var goaway = toGoawayPayload(parsePayload(event));
+      settle({
+        outcome: goaway.action === 'close' ? 'goaway-close' : 'goaway',
+        goaway: goaway
+      }, {
+        notifyClosed: true
+      });
+    });
+    source.onerror = function () {
+      return settle({
+        outcome: 'error'
+      }, {
+        notifyClosed: true
+      });
+    };
+    var onAbort = function onAbort() {
+      return settle({
+        outcome: 'error'
+      }, {
+        notifyClosed: false
+      });
+    };
+    signal.addEventListener('abort', onAbort);
+    source.addEventListener(SERVER_CONNECTION_EVENTS.hello, function () {
+      if (settled) {
+        return;
+      }
+      if (hooks.onHello()) {
+        clearTimeout(helloTimer);
+      }
+    });
+  });
+};
+
+// 상태 코드 → 사유 매핑이 단일 원천입니다 — 멈출 코드 판정과 사유가 같은 표에서 나와 어긋날 수 없습니다
+var TICKET_FATAL_CAUSES = {
+  401: 'auth',
+  403: 'auth',
+  429: 'rate_limit'
+};
+var isFatalTicketStatus = function isFatalTicketStatus(status) {
+  return status in TICKET_FATAL_CAUSES;
+};
+var HELLO_TIMEOUT_MS = 10000;
+// 즉시 실패(CORS·오프라인)의 기본 백오프(full jitter) 기준 최대 15초, 보통 7~8초 안에 알립니다 — 순간 끊김에는 침묵합니다
+var STALLED_AFTER_ATTEMPTS = 5;
+/** @description SSR 환경에서도 안전하게 생성할 수 있습니다 — 연결은 connect()를 호출할 때 시작됩니다 */
+var _backoff = /*#__PURE__*/new WeakMap();
+var _machine = /*#__PURE__*/new WeakMap();
+var _currentStream = /*#__PURE__*/new WeakMap();
+var _abort = /*#__PURE__*/new WeakMap();
+var _hasOpened = /*#__PURE__*/new WeakMap();
+var _networkFailures = /*#__PURE__*/new WeakMap();
+var _SseClient_brand = /*#__PURE__*/new WeakSet();
+var SseClient = /*#__PURE__*/function (_BaseSseClient) {
+  function SseClient(options) {
+    var _internals$hasOpenedB;
+    var _this;
+    var internals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, SseClient);
+    _this = _callSuper(this, SseClient, [options.logger]);
+    // 한 연결 세션을 접습니다 — 다음 connect()가 첫 연결처럼 시작하도록 재수립 판단과 백오프도 함께 되돌립니다
+    _classPrivateMethodInitSpec(_this, _SseClient_brand);
+    _defineProperty(_this, "options", void 0);
+    _defineProperty(_this, "internals", void 0);
+    _classPrivateFieldInitSpec(_this, _backoff, void 0);
+    _classPrivateFieldInitSpec(_this, _machine, void 0);
+    _classPrivateFieldInitSpec(_this, _currentStream, null);
+    _classPrivateFieldInitSpec(_this, _abort, null);
+    _classPrivateFieldInitSpec(_this, _hasOpened, void 0);
+    _classPrivateFieldInitSpec(_this, _networkFailures, 0);
+    _this.options = options;
+    _this.internals = internals;
+    _classPrivateFieldSet2(_hasOpened, _this, (_internals$hasOpenedB = internals.hasOpenedBefore) !== null && _internals$hasOpenedB !== void 0 ? _internals$hasOpenedB : false);
+    _classPrivateFieldSet2(_backoff, _this, createBackoff(options.backoff));
+    _classPrivateFieldSet2(_machine, _this, createStatusMachine(function (status) {
+      return _this.emitter.emitStatus(status);
+    }));
+    return _this;
+  }
+  _inherits(SseClient, _BaseSseClient);
+  return _createClass(SseClient, [{
+    key: "status",
+    get: function get() {
+      return _classPrivateFieldGet2(_machine, this).status;
+    }
+  }, {
+    key: "connect",
+    value: function connect() {
+      var _this$options$eventSo,
+        _this2 = this;
+      if (((_this$options$eventSo = this.options.eventSource) !== null && _this$options$eventSo !== void 0 ? _this$options$eventSo : globalThis.EventSource) === undefined) {
+        // SSR 대응 - no-op
+        return;
+      }
+      var controller = new AbortController();
+      var previous = _classPrivateFieldGet2(_abort, this);
+      // 전이 통지 중 리스너가 disconnect()해도 이 controller가 abort되도록 전이보다 먼저 교체합니다
+      _classPrivateFieldSet2(_abort, this, controller);
+      if (!_classPrivateFieldGet2(_machine, this).transition('connect')) {
+        _classPrivateFieldSet2(_abort, this, previous);
+        if (_classPrivateFieldGet2(_machine, this).status === 'fatal') {
+          var _this$options$logger;
+          (_this$options$logger = this.options.logger) === null || _this$options$logger === void 0 || _this$options$logger.warn('sse: fatal 상태에서는 connect()가 무시됩니다 — disconnect()로 정리한 뒤 다시 connect() 하세요');
+        }
+        return;
+      }
+      if (controller.signal.aborted) {
+        return;
+      }
+      // 루프가 예외로 죽으면 재시도가 영영 없습니다 — fatal로 떨어뜨려 회복 경로(정리 후 connect)에 맡깁니다
+      void _assertClassBrand(_SseClient_brand, this, _runConnection).call(this, controller.signal)["catch"](function (error) {
+        var _this2$options$logger;
+        (_this2$options$logger = _this2.options.logger) === null || _this2$options$logger === void 0 || _this2$options$logger.error('sse: 연결 루프가 예외로 중단됐습니다', error);
+        // 전이가 거부된 상태(reconnecting 등)에서 발화하면 "전이 후 발화" 계약이 깨집니다
+        if (_classPrivateFieldGet2(_machine, _this2).transition('fatalFailure')) {
+          _this2.emitter.emit(SDK_EVENTS.fatal, {
+            cause: 'unknown'
+          });
+        }
+      });
+    }
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      var _classPrivateFieldGet2$1;
+      // abort가 연결 루프를 중단합니다 — 진행 중이던 티켓 발급·대기·스트림 전부
+      (_classPrivateFieldGet2$1 = _classPrivateFieldGet2(_abort, this)) === null || _classPrivateFieldGet2$1 === void 0 || _classPrivateFieldGet2$1.abort();
+      _classPrivateFieldSet2(_abort, this, null);
+      _assertClassBrand(_SseClient_brand, this, _endSession).call(this);
+      _classPrivateFieldGet2(_machine, this).transition('disconnect');
+    }
+  }, {
+    key: "registerSubscription",
+    value:
+    // 열린 스트림이 없으면 조용히 넘어갑니다 — 다음 #openStream이 구독 장부를 보고 한 번에 붙입니다
+    function registerSubscription(type) {
+      _assertClassBrand(_SseClient_brand, this, _attachSourceListener).call(this, type);
+    }
+    // 티켓 발급 → 스트림 유지 → 끊김 → 대기 → 재시도. disconnect(abort)만이 루프를 종료합니다
+  }]);
+}(BaseSseClient);
+function _endSession() {
+  _assertClassBrand(_SseClient_brand, this, _closeStream).call(this);
+  _classPrivateFieldSet2(_hasOpened, this, false);
+  _classPrivateFieldGet2(_backoff, this).reset();
+  _classPrivateFieldSet2(_networkFailures, this, 0);
+}
+/**
+ * @description hello에 닿지 못한 네트워크성(응답 status 부재) 연속 실패를 셉니다 — 임계값 도달 순간에만
+ * stalled를 발화해 한 구간에 한 번만 알립니다. 반드시 상태 전이 뒤에 부르세요.
+ * 연속은 open 도달과 서버 응답(5xx)이 끊고, 스트림 단계 실패는 status가 없어 전부 여기 해당합니다.
+ */
+function _countNetworkFailure() {
+  _classPrivateFieldSet2(_networkFailures, this, _classPrivateFieldGet2(_networkFailures, this) + 1);
+  if (_classPrivateFieldGet2(_networkFailures, this) === STALLED_AFTER_ATTEMPTS) {
+    this.emitter.emit(SDK_EVENTS.stalled, undefined);
+  }
+}
+function _runConnection(_x) {
+  return _runConnection2.apply(this, arguments);
+}
+function _runConnection2() {
+  _runConnection2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(signal) {
+    var next;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (signal.aborted) {
+            _context.next = 14;
+            break;
+          }
+          _context.next = 3;
+          return _assertClassBrand(_SseClient_brand, this, _attemptConnection).call(this, signal);
+        case 3:
+          next = _context.sent;
+          if (!(signal.aborted || next === 'stop')) {
+            _context.next = 6;
+            break;
+          }
+          return _context.abrupt("return");
+        case 6:
+          if (!(next === 'retryWithDelay')) {
+            _context.next = 11;
+            break;
+          }
+          _context.next = 9;
+          return waitForRetry(_classPrivateFieldGet2(_backoff, this).nextDelayMs(), signal);
+        case 9:
+          if (!signal.aborted) {
+            _context.next = 11;
+            break;
+          }
+          return _context.abrupt("return");
+        case 11:
+          _classPrivateFieldGet2(_machine, this).transition('readyToRetry');
+          _context.next = 0;
+          break;
+        case 14:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, this);
+  }));
+  return _runConnection2.apply(this, arguments);
+}
+// 스트림이 끊길 때까지 대기하고, 루프의 다음 동작('stop'·'retryWithDelay'·'retryNow')을 반환합니다
+function _attemptConnection(_x2) {
+  return _attemptConnection2.apply(this, arguments);
+}
+function _attemptConnection2() {
+  _attemptConnection2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(signal) {
+    var _this$internals$issue, _this$internals$issue2, _this$internals;
+    var result, _result$error, status, cause, _this$options$logger2, outcome, _this$options$logger3;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return (_this$internals$issue = (_this$internals$issue2 = (_this$internals = this.internals).issueTicket) === null || _this$internals$issue2 === void 0 ? void 0 : _this$internals$issue2.call(_this$internals)) !== null && _this$internals$issue !== void 0 ? _this$internals$issue : issueTicketWithTimeout(this.options);
+        case 2:
+          result = _context2.sent;
+          if (!signal.aborted) {
+            _context2.next = 5;
+            break;
+          }
+          return _context2.abrupt("return", 'stop');
+        case 5:
+          if (result.ok) {
+            _context2.next = 19;
+            break;
+          }
+          _result$error = result.error, status = _result$error.status, cause = _result$error.cause; // 로그는 원인 예외를 쥔 ticket.ts가 남깁니다 — 여기서 또 찍으면 직결 경로에서 같은 말이 두 줄 됩니다
+          if (!(cause === 'auth_callback')) {
+            _context2.next = 11;
+            break;
+          }
+          _classPrivateFieldGet2(_machine, this).transition('fatalFailure');
+          this.emitter.emit(SDK_EVENTS.fatal, {
+            cause: 'auth_callback'
+          });
+          return _context2.abrupt("return", 'stop');
+        case 11:
+          if (!(status !== undefined && isFatalTicketStatus(status))) {
+            _context2.next = 16;
+            break;
+          }
+          (_this$options$logger2 = this.options.logger) === null || _this$options$logger2 === void 0 || _this$options$logger2.warn("sse: \uD2F0\uCF13 \uBC1C\uAE09\uC774 ".concat(status, "\uB85C \uAC70\uBD80\uB418\uC5B4 \uBA48\uCDA5\uB2C8\uB2E4 \u2014 disconnect()\uB85C \uC815\uB9AC\uD55C \uB4A4 \uB2E4\uC2DC connect() \uD558\uC138\uC694"));
+          _classPrivateFieldGet2(_machine, this).transition('fatalFailure');
+          // 전이를 마친 뒤 알립니다 — 핸들러가 그 자리에서 disconnect()·connect() 회복을 시작할 수 있게
+          this.emitter.emit(SDK_EVENTS.fatal, {
+            cause: TICKET_FATAL_CAUSES[status],
+            status: status
+          });
+          return _context2.abrupt("return", 'stop');
+        case 16:
+          _classPrivateFieldGet2(_machine, this).transition('retryableFailure');
+          // 서버가 응답한 거부(5xx 등)는 네트워크성이 아니라 세지 않습니다 — 서버 장애에 네트워크 안내가 나가는 오안내를 막습니다
+          if (status === undefined) {
+            _assertClassBrand(_SseClient_brand, this, _countNetworkFailure).call(this);
+          } else {
+            _classPrivateFieldSet2(_networkFailures, this, 0);
+          }
+          return _context2.abrupt("return", 'retryWithDelay');
+        case 19:
+          _context2.prev = 19;
+          _context2.next = 22;
+          return _assertClassBrand(_SseClient_brand, this, _openStream).call(this, result.ticket, signal);
+        case 22:
+          outcome = _context2.sent;
+          if (!(outcome === 'goaway-close')) {
+            _context2.next = 25;
+            break;
+          }
+          return _context2.abrupt("return", 'stop');
+        case 25:
+          return _context2.abrupt("return", outcome === 'goaway' ? 'retryNow' : 'retryWithDelay');
+        case 28:
+          _context2.prev = 28;
+          _context2.t0 = _context2["catch"](19);
+          (_this$options$logger3 = this.options.logger) === null || _this$options$logger3 === void 0 || _this$options$logger3.error('sse: EventSource 생성 실패 — baseUrl을 확인하세요', _context2.t0);
+          _classPrivateFieldGet2(_machine, this).transition('fatalFailure');
+          // 생성의 동기 throw는 설정 실수입니다 — 네트워크성 실패는 onerror로 와서 reconnecting으로 갑니다
+          this.emitter.emit(SDK_EVENTS.fatal, {
+            cause: 'config'
+          });
+          return _context2.abrupt("return", 'stop');
+        case 34:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, this, [[19, 28]]);
+  }));
+  return _attemptConnection2.apply(this, arguments);
+}
+// EventSource를 생성하고 스트림이 끊길 때까지 대기합니다 — 이벤트 연결은 stream.ts, 여기서는 상태 전이만 담당합니다
+function _openStream(ticket, signal) {
+  var _this$options$eventSo2,
+    _this3 = this;
+  var EventSourceImpl = (_this$options$eventSo2 = this.options.eventSource) !== null && _this$options$eventSo2 !== void 0 ? _this$options$eventSo2 : globalThis.EventSource;
+  var source = new EventSourceImpl("".concat(this.options.baseUrl, "/v1/events?ticket=").concat(encodeURIComponent(ticket)));
+  _classPrivateFieldSet2(_currentStream, this, {
+    source: source,
+    attachedEvents: new Set()
+  });
+  this.emitter.handlerTypes().forEach(function (type) {
+    return _assertClassBrand(_SseClient_brand, _this3, _attachSourceListener).call(_this3, type);
+  });
+  // hello 전 끊김(타임아웃 포함)만 미연결로 셉니다 — 수립 후 끊김은 다음 시도부터 다시 셉니다
+  var opened = false;
+  return streamUntilClosed(source, signal, {
+    helloTimeoutMs: HELLO_TIMEOUT_MS,
+    onHello: function onHello() {
+      if (!_classPrivateFieldGet2(_machine, _this3).transition('hello')) {
+        return false;
+      }
+      if (signal.aborted) {
+        return false;
+      }
+      opened = true;
+      _classPrivateFieldGet2(_backoff, _this3).reset();
+      _classPrivateFieldSet2(_networkFailures, _this3, 0);
+      // 갱신 전에 읽어야 이번 hello를 뺀 값입니다 — 두 번째부터가 재수립입니다
+      var isReestablished = _classPrivateFieldGet2(_hasOpened, _this3);
+      _classPrivateFieldSet2(_hasOpened, _this3, true);
+      if (isReestablished) {
+        _this3.emitter.emit(SDK_EVENTS.resync, undefined);
+      }
+      return true;
+    },
+    onClosed: function onClosed(closure) {
+      if (closure.outcome === 'error') {
+        _assertClassBrand(_SseClient_brand, _this3, _closeStream).call(_this3);
+        _classPrivateFieldGet2(_machine, _this3).transition('retryableFailure');
+        if (!opened) {
+          _assertClassBrand(_SseClient_brand, _this3, _countNetworkFailure).call(_this3);
+        }
+        return;
+      }
+      // 서버가 재연결하지 말라고 했으면 reconnecting을 거치지 않습니다 — 소비처에 헛된 재연결 중을 보이지 않게
+      if (closure.outcome === 'goaway-close') {
+        _assertClassBrand(_SseClient_brand, _this3, _endSession).call(_this3);
+        _classPrivateFieldGet2(_machine, _this3).transition('disconnect');
+      } else {
+        _assertClassBrand(_SseClient_brand, _this3, _closeStream).call(_this3);
+        _classPrivateFieldGet2(_machine, _this3).transition('retryableFailure');
+      }
+      // 전이를 마친 뒤 알립니다 — 핸들러가 그 자리에서 connect()·disconnect()를 부를 수 있게
+      _this3.emitter.emit(SERVER_CONNECTION_EVENTS.goaway, closure.goaway);
+    }
+  });
+}
+function _attachSourceListener(type) {
+  var _this4 = this;
+  if (_classPrivateFieldGet2(_currentStream, this) === null) {
+    return;
+  }
+  var _classPrivateFieldGet3 = _classPrivateFieldGet2(_currentStream, this),
+    source = _classPrivateFieldGet3.source,
+    attachedEvents = _classPrivateFieldGet3.attachedEvents;
+  attachDomainListener(source, attachedEvents, type, function (t, payload) {
+    return _this4.emitter.emit(t, payload);
+  });
+}
+function _closeStream() {
+  var _classPrivateFieldGet4;
+  (_classPrivateFieldGet4 = _classPrivateFieldGet2(_currentStream, this)) === null || _classPrivateFieldGet4 === void 0 || _classPrivateFieldGet4.source.close();
+  _classPrivateFieldSet2(_currentStream, this, null);
+}
+
+var isDeadStatus = function isDeadStatus(status) {
+  return status === 'fatal' || status === 'closed';
+};
+/**
+ * @description 모든 탭이 함께 쓰는 워커의 연결 하나 — 수립·정리와 구독 부착을 맡습니다.
+ * 탭 장부(hub)는 "탭이 남았는가"만 판단하고, 그 판단을 연결에 적용하는 방법은 여기서만 압니다.
+ */
+var createWorkerConnection = function createWorkerConnection(_ref) {
+  var options = _ref.options,
+    ticketDelegate = _ref.ticketDelegate,
+    onStatus = _ref.onStatus,
+    onEvent = _ref.onEvent;
+  var subscriptions = new Set();
+  // 하나로 묶어 셋이 따로 노는 상태를 표현 불가능하게 만듭니다
+  var active = null;
+  // 인스턴스보다 오래 삽니다 — 재수립 판정이 SseClient 수명에 묶이면 접힌 뒤 복구에서 resync가 사라집니다
+  var hasOpenedBefore = false;
+  var attach = function attach(client, event) {
+    client.on(event, function (payload) {
+      return onEvent(event, payload);
+    });
+  };
+  var open = function open(baseUrl) {
+    // 워커 스코프에는 토큰이 없습니다 — 티켓은 issueTicket으로 탭에 위임하므로 이 값은 쓰이지 않습니다
+    var client = new SseClient(_objectSpread2(_objectSpread2({}, options), {}, {
+      baseUrl: baseUrl,
+      getAuthToken: function getAuthToken() {
+        return null;
+      }
+    }), {
+      issueTicket: ticketDelegate.request,
+      hasOpenedBefore: hasOpenedBefore
+    });
+    var detachStatus = client.onStatus(function (next) {
+      // open에 닿았다는 건 hello를 받았다는 뜻입니다 — 인스턴스가 바뀌어도 이 사실은 남아야 합니다
+      if (next === 'open') {
+        hasOpenedBefore = true;
+      }
+      // 이 리스너에 닿는 closed는 goaway(action: close)뿐입니다(자체 close는 먼저 detach) —
+      // 서버가 세션을 끝냈으니 직결 경로(#endSession)와 같은 판정으로 다음 연결은 첫 연결입니다
+      if (next === 'closed') {
+        hasOpenedBefore = false;
+      }
+      onStatus(next);
+    });
+    active = {
+      client: client,
+      detachStatus: detachStatus,
+      baseUrl: baseUrl
+    };
+    FORWARDED_EVENTS.forEach(function (event) {
+      return attach(client, event);
+    });
+    subscriptions.forEach(function (event) {
+      return attach(client, event);
+    });
+    client.connect();
+  };
+  /**
+   * @description 연결을 접습니다. endSession이면 재수립 판정도 함께 되돌립니다.
+   * 탭이 모두 스스로 떠났으면 세션이 끝난 것이고, 다음 탭에게는 첫 연결입니다 —
+   * 이어서 두면 신규 탭이 놓친 구간도 없이 resync를 받습니다.
+   */
+  var close = function close() {
+    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref2$endSession = _ref2.endSession,
+      endSession = _ref2$endSession === void 0 ? false : _ref2$endSession;
+    if (endSession) {
+      hasOpenedBefore = false;
+    }
+    if (active === null) {
+      return;
+    }
+    // 정리 중 나오는 closed는 워커 내부 사정입니다 — 탭에 전하기 전에 통지를 끊습니다
+    active.detachStatus();
+    active.client.disconnect();
+    active = null;
+    ticketDelegate.cancel();
+    // 연결이 없어졌다는 사실은 알려야 합니다 — 안 그러면 뒤에 합류한 탭이 낡은 open 스냅샷을 받습니다
+    onStatus('idle');
+  };
+  return {
+    ensureOpen: function ensureOpen(baseUrl) {
+      if (active !== null && isDeadStatus(active.client.status)) {
+        close();
+      }
+      if (active === null) {
+        open(baseUrl);
+        return;
+      }
+      // 선 연결을 그대로 씁니다 — 다른 baseUrl로 붙으려던 탭은 그 사실을 알 길이 없어 알립니다
+      if (baseUrl !== active.baseUrl) {
+        var _options$logger;
+        (_options$logger = options.logger) === null || _options$logger === void 0 || _options$logger.warn("sse: \uC774\uBBF8 ".concat(active.baseUrl, "\uB85C \uC5F0\uACB0\uB3FC \uC788\uC5B4 baseUrl(").concat(baseUrl, ")\uC744 \uBB34\uC2DC\uD569\uB2C8\uB2E4"));
+      }
+    },
+    close: close,
+    /** @description 선 연결에는 즉시, 이후 연결에는 수립 시점에 붙습니다 */
+    subscribe: function subscribe(event) {
+      if (subscriptions.has(event)) {
+        return;
+      }
+      subscriptions.add(event);
+      if (active !== null) {
+        attach(active.client, event);
+      }
+    },
+    subscribedEvents: function subscribedEvents() {
+      return _toConsumableArray(subscriptions);
+    }
+  };
+};
+
+/**
+ * @description SharedWorker 쪽 메시지 라우팅 — 탭이 보낸 것을 연결에 전하고, 연결이 낸 것을 탭에 전합니다.
+ * 포트 장부(frozen 탭을 빼지 않는 이유 포함)는 portRegistry가, 연결 수립·정리는 workerConnection이 소유합니다.
+ * 배선 현황은 protocol.ts의 지도를 보세요.
+ */
+var createWorkerHub = function createWorkerHub() {
+  var hubOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  // 늦게 합류한 탭에 스냅샷으로 보냅니다 — 저장과 통지가 어긋나지 않게 setStatus로만 바꿉니다
+  var status = 'idle';
+  var registry = createPortRegistry();
+  var broadcast = function broadcast(message) {
+    registry.forEach(function (port) {
+      return port.postMessage(message);
+    });
+  };
+  var setStatus = function setStatus(next) {
+    status = next;
+    broadcast({
+      kind: 'status',
+      status: next
+    });
+  };
+  var ticketDelegate = createTicketDelegate(function () {
+    var target = registry.livelyPort();
+    if (target !== undefined) {
+      target.postMessage({
+        kind: 'ticket-request'
+      });
+      return;
+    }
+    // 전원이 침묵하면 접습니다 — 세션 종료가 아니라 휴면이라, 재수립 판정은 그대로 둡니다.
+    // microtask인 이유: 이 콜백은 연결 루프의 티켓 발급 스택 안이라, 동기로 접으면 그 루프를 재진입으로 끊습니다
+    queueMicrotask(function () {
+      return connection.close();
+    });
+  });
+  var connection = createWorkerConnection({
+    options: hubOptions,
+    ticketDelegate: ticketDelegate,
+    onStatus: setStatus,
+    onEvent: function onEvent(event, payload) {
+      return broadcast({
+        kind: 'event',
+        event: event,
+        payload: payload
+      });
+    }
+  });
+  return {
+    addPort: function addPort(port) {
+      registry.add(port);
+      port.postMessage({
+        kind: 'status',
+        status: status
+      });
+    },
+    handleMessage: function handleMessage(port, data) {
+      // close로 떠난 포트의 늦은 메시지만 거릅니다 — frozen 탭은 장부에 남아 그대로 지나갑니다
+      if (!registry.has(port)) {
+        return;
+      }
+      // 어떤 메시지든 생존 증거입니다 — pong만 세면 깨어나 init부터 보낸 탭이 침묵으로 남아 티켓을 못 받습니다
+      registry.markAlive(port);
+      var message = data;
+      switch (message === null || message === void 0 ? void 0 : message.kind) {
+        case 'init':
+          // 휴면(전원 침묵)으로 접힌 연결은 깨어난 탭의 이 신호로 다시 섭니다
+          if (typeof message.baseUrl === 'string') {
+            connection.ensureOpen(message.baseUrl);
+          }
+          return;
+        case 'subscribe':
+          // 예약 이벤트·비문자열은 프록시가 걸러 보내지만, 구버전·타 구현 탭에 대비해 한 번 더 거릅니다
+          if (typeof message.event === 'string' && isSubscribableEvent(message.event)) {
+            connection.subscribe(message.event);
+          }
+          return;
+        case 'ticket-response':
+          // 여기서 거르지 않으면 잘못된 응답이 연결 루프를 예외로 죽여 워커가 고착됩니다
+          if (isTicketResponse(message)) {
+            ticketDelegate.settle(message);
+          }
+          return;
+        case 'pong':
+          // 생존 표시는 위에서 이미 끝났습니다 — pong은 그 증거만 나르는 메시지입니다
+          return;
+        case 'close':
+          {
+            var _registry$close = registry.close(port),
+              wasLast = _registry$close.wasLast;
+            // 모두 스스로 떠났으니 세션이 끝났습니다 — 다음 탭에게는 첫 연결입니다
+            if (wasLast) {
+              connection.close({
+                endSession: true
+              });
+            }
+            return;
+          }
+        default:
+          return;
+      }
+    },
+    broadcast: broadcast,
+    tabCount: registry.size,
+    subscribedEvents: connection.subscribedEvents
+  };
+};
+
+var hub = createWorkerHub();
+self.onconnect = function (event) {
+  var port = event.ports[0];
+  if (port === undefined) {
+    return;
+  }
+  hub.addPort(port);
+  port.onmessage = function (message) {
+    return hub.handleMessage(port, message.data);
+  };
+  port.start();
+};
+//# sourceMappingURL=sse.worker.js.map