@jucie.io/cli 1.0.0

package/dist/stage-bundles/preact/chunks/chunk-JJVRBJGQ.js

@@ -0,0 +1,1353 @@
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __publicField,
+  __require
+} from "./chunk-4A4WKSGY.js";
+
+// ../../node_modules/@jucie.io/engine/dist/main.js
+var p = { PRIMITIVE: 0, OBJECT: 1, ARRAY: 2, RESERVED: 3 };
+var S = class r {
+  constructor(e) {
+    this.flags = 0, e !== void 0 && (typeof e == "function" ? this.flags |= 1 : e instanceof Set || e instanceof Map ? (this.value = e, this.originalType = p.PRIMITIVE) : typeof e == "object" && e !== null && !Array.isArray(e) ? (this._children = new Map(Object.entries(e).map(([t, n]) => [t, new r(n)])), this.flags |= 16, this.originalType = p.OBJECT) : Array.isArray(e) ? (this._children = new Map(e.map((t, n) => [n, new r(t)])), this.flags |= 16, this.originalType = p.ARRAY) : (this.value = e, this.originalType = p.PRIMITIVE));
+  }
+  get isFunction() {
+    return (this.flags & 1) !== 0;
+  }
+  set isFunction(e) {
+    this.flags = e ? this.flags | 1 : this.flags & -2;
+  }
+  get isSetOnce() {
+    return (this.flags & 2) !== 0;
+  }
+  set isSetOnce(e) {
+    this.flags = e ? this.flags | 2 : this.flags & -3;
+  }
+  get cached() {
+    return (this.flags & 4) !== 0;
+  }
+  set cached(e) {
+    this.flags = e ? this.flags | 4 : this.flags & -5;
+  }
+  get executed() {
+    return (this.flags & 8) !== 0;
+  }
+  set executed(e) {
+    this.flags = e ? this.flags | 8 : this.flags & -9;
+  }
+  get hasChildrenFlag() {
+    return (this.flags & 16) !== 0;
+  }
+  set hasChildrenFlag(e) {
+    this.flags = e ? this.flags | 16 : this.flags & -17;
+  }
+  get isFixed() {
+    return (this.flags & 32) !== 0;
+  }
+  set isFixed(e) {
+    this.flags = e ? this.flags | 32 : this.flags & -33;
+  }
+  get originalType() {
+    return this.flags >> 6 & 3;
+  }
+  set originalType(e) {
+    this.flags = this.flags & -193 | (e & 3) << 6;
+  }
+  get children() {
+    return this._children || (this._children = /* @__PURE__ */ new Map(), this.hasChildrenFlag = true), this._children;
+  }
+  hasChildren() {
+    return this.hasChildrenFlag && this._children && this._children.size > 0;
+  }
+  isEmpty() {
+    return this.value === void 0 && (!this._children || this._children.size === 0);
+  }
+  get cachedResult() {
+    return this._cachedResult;
+  }
+  set cachedResult(e) {
+    this._cachedResult = e;
+  }
+  get cachedAt() {
+    return this._cachedAt;
+  }
+  set cachedAt(e) {
+    this._cachedAt = e;
+  }
+  get(e) {
+    let t = e.shift();
+    if (t === void 0) {
+      if (this.flags & 1) {
+        if ((this.flags & 6) === 6) return this.cachedResult;
+        let n = this.value();
+        return this.flags & 2 && (this.flags |= 4, this.cachedResult = n, this.cachedAt = Date.now()), this.flags |= 8, n;
+      }
+      return this.value !== void 0 ? this.value : this.hasChildren() ? this._reconstructFromChildren() : void 0;
+    }
+    if (this._children?.has(t)) return this._children.get(t).get(e);
+  }
+  set(e, t) {
+    let n = e.shift();
+    if (n === void 0) {
+      if (this.isFixed) throw new Error("Cannot overwrite fixed value at path. Use clearFixed() first if you need to modify it.");
+      return t instanceof Set || t instanceof Map ? (this.value = t, this.flags = 0, this.originalType = p.PRIMITIVE) : typeof t == "object" && t !== null && !Array.isArray(t) && typeof t != "function" ? this._syncObjectChildren(t) : Array.isArray(t) ? this._syncArrayChildren(t) : (this.value = t, this.flags = typeof t == "function" ? 1 : 0, this.originalType = p.PRIMITIVE), this;
+    }
+    let i = this.children;
+    return i.has(n) || i.set(n, new r()), i.get(n).set(e, t), this;
+  }
+  setOnce(e, t) {
+    let n = e.shift();
+    if (n === void 0) {
+      if (this.isFixed) throw new Error("Cannot overwrite fixed value at path. Use clearFixed() first if you need to modify it.");
+      return t instanceof Set || t instanceof Map ? (this.value = t, this.flags = 2, this.originalType = p.PRIMITIVE) : typeof t == "object" && t !== null && !Array.isArray(t) && typeof t != "function" ? (this._syncObjectChildren(t), this.flags = this.flags | 2) : Array.isArray(t) ? (this._syncArrayChildren(t), this.flags = this.flags | 2) : (this.value = t, this.flags = typeof t == "function" ? 3 : 2, this.originalType = p.PRIMITIVE), this;
+    }
+    let i = this.children;
+    return i.has(n) || i.set(n, new r()), i.get(n).setOnce(e, t), this;
+  }
+  has(e) {
+    let t = e.shift();
+    return t === void 0 ? this.value !== void 0 || this.hasChildren() : this._children?.has(t) ? this._children.get(t).has(e) : false;
+  }
+  hasValue(e) {
+    let t = e.shift();
+    return t === void 0 ? this.value !== void 0 : this._children?.has(t) ? this._children.get(t).hasValue(e) : false;
+  }
+  remove(e) {
+    let t = e.shift();
+    if (t === void 0) return this.value = void 0, this._children = void 0, this.flags = this.flags & -32, this;
+    if (this._children?.has(t)) {
+      let n = this._children.get(t);
+      n.remove(e), n.isEmpty() && this._children.delete(t);
+    }
+    return this;
+  }
+  clearCache(e) {
+    let t = e.shift();
+    return t === void 0 ? (this.flags = this.flags & -5, this.cachedResult = null, this.cachedAt = null, this) : (this._children?.has(t) && this._children.get(t).clearCache(e), this);
+  }
+  fixed(e, t) {
+    let n = e.shift();
+    if (n === void 0) {
+      if (this.value !== void 0 && this.isFixed) throw new Error("Value at path is already fixed and cannot be changed. Use clearFixed() first if needed.");
+      return this.value = t, this.flags = (typeof t == "function" ? 1 : 0) | 32, this;
+    }
+    let i = this.children;
+    return i.has(n) || i.set(n, new r()), i.get(n).fixed(e, t), this;
+  }
+  clearFixed(e) {
+    let t = e.shift();
+    return t === void 0 ? this.isFixed ? (this.flags = this.flags & -33, this) : (console.warn("Attempted to clear fixed flag on non-fixed value"), this) : (this._children?.has(t) && this._children.get(t).clearFixed(e), this);
+  }
+  isFixedValue(e) {
+    let t = e.shift();
+    return t === void 0 ? this.isFixed : this._children?.has(t) ? this._children.get(t).isFixedValue(e) : false;
+  }
+  _syncObjectChildren(e) {
+    let t = new Set(Object.keys(e)), n = new Set(this.children.keys());
+    for (let i of n) t.has(i) || this.children.delete(i);
+    for (let [i, s] of Object.entries(e)) if (this.children.has(i) || this.children.set(i, new r()), typeof s == "object" && s !== null && !Array.isArray(s) && typeof s != "function") this.children.get(i)._syncObjectChildren(s);
+    else if (Array.isArray(s)) this.children.get(i)._syncArrayChildren(s);
+    else {
+      let o = this.children.get(i);
+      o.value = s, o.flags = typeof s == "function" ? 1 : 0;
+    }
+    this.value = void 0, this.flags = this.flags & -2, this.originalType = p.OBJECT;
+  }
+  _syncArrayChildren(e) {
+    let t = new Set(e.map((i, s) => s)), n = new Set(this.children.keys());
+    for (let i of n) typeof i == "number" && !t.has(i) && this.children.delete(i);
+    for (let i = 0; i < e.length; i++) {
+      let s = e[i];
+      if (this.children.has(i) || this.children.set(i, new r()), typeof s == "object" && s !== null && !Array.isArray(s) && typeof s != "function") this.children.get(i)._syncObjectChildren(s);
+      else if (Array.isArray(s)) this.children.get(i)._syncArrayChildren(s);
+      else {
+        let o = this.children.get(i);
+        o.value = s, o.flags = typeof s == "function" ? 1 : 0;
+      }
+    }
+    this.value = void 0, this.flags = this.flags & -2, this.originalType = p.ARRAY;
+  }
+  _reconstructFromChildren() {
+    if (!this._children || this._children.size === 0) return;
+    if (this.originalType === p.ARRAY) {
+      let t = [];
+      for (let [n, i] of this._children) typeof n == "number" && (t[n] = i.get([]));
+      return t;
+    } else {
+      let t = {};
+      for (let [n, i] of this._children) t[n] = i.get([]);
+      return t;
+    }
+  }
+};
+var m = class r2 {
+  static create(e) {
+    return new r2(e);
+  }
+  constructor(e = {}) {
+    return this.load(e);
+  }
+  load(e) {
+    return this.root = new S(e), this;
+  }
+  get(e) {
+    let t = Array.isArray(e) ? [...e] : [e];
+    return this.root.get(t);
+  }
+  update(e, t) {
+    let n = Array.isArray(e) ? [...e] : [e], i = this.root.get([...n]), s = t(i);
+    return this.root.set([...n], s), this;
+  }
+  set(e, t) {
+    let n = Array.isArray(e) ? [...e] : [e];
+    return this.root.set(n, t), this;
+  }
+  setOnce(e, t) {
+    let n = Array.isArray(e) ? [...e] : [e];
+    return this.root.setOnce(n, t), this;
+  }
+  fixed(e, t) {
+    let n = Array.isArray(e) ? [...e] : [e];
+    return this.root.fixed(n, t), this;
+  }
+  has(e) {
+    let t = Array.isArray(e) ? [...e] : [e];
+    return this.root.has(t);
+  }
+  hasValue(e) {
+    let t = Array.isArray(e) ? [...e] : [e];
+    return this.root.hasValue(t);
+  }
+  remove(e) {
+    let t = Array.isArray(e) ? [...e] : [e];
+    return this.root.remove(t), this;
+  }
+  clearCache(e) {
+    let t = Array.isArray(e) ? [...e] : [e];
+    return this.root.clearCache(t), this;
+  }
+  clearFixed(e) {
+    let t = Array.isArray(e) ? [...e] : [e];
+    return this.root.clearFixed(t), this;
+  }
+  isFixed(e) {
+    let t = Array.isArray(e) ? [...e] : [e];
+    return this.root.isFixedValue(t);
+  }
+  export() {
+    return this._exportNode(this.root);
+  }
+  static import(e) {
+    let t = new r2();
+    return t.root = t._importNode(e), t;
+  }
+  _exportNode(e) {
+    let t = { flags: e.flags };
+    if (e.isFunction) t.type = "function", t.skipped = true;
+    else if (e.hasChildren()) {
+      t.type = "map", t.value = [];
+      for (let [n, i] of e._children) t.value.push([n, this._exportNode(i)]);
+      e.value !== void 0 && (t.nodeValue = e.value);
+    } else e.value !== void 0 ? (t.type = "primitive", t.value = e.value) : t.type = "empty";
+    return t;
+  }
+  _importNode(e) {
+    let t = new S();
+    switch (t.flags = e.flags || 0, e.type) {
+      case "function":
+        t.value = void 0, t.flags = t.flags & -16;
+        break;
+      case "primitive":
+        t.value = e.value;
+        break;
+      case "map":
+        if (e.value && e.value.length > 0) {
+          t._children = /* @__PURE__ */ new Map();
+          for (let [n, i] of e.value) {
+            let s = typeof n == "string" && /^\d+$/.test(n) ? parseInt(n, 10) : n;
+            t._children.set(s, this._importNode(i));
+          }
+          t.hasChildrenFlag = true;
+        }
+        e.nodeValue !== void 0 && (t.value = e.nodeValue);
+        break;
+      case "empty":
+      default:
+        break;
+    }
+    return t;
+  }
+};
+var b = Object.freeze(/* @__PURE__ */ Object.create(null));
+function ae(r3) {
+  if (globalThis.queueMicrotask && typeof globalThis.queueMicrotask == "function") {
+    globalThis.queueMicrotask(r3);
+    return;
+  }
+  setTimeout(r3, 0);
+}
+var _e, _t, _a;
+var j = (_a = class {
+  constructor(e, t) {
+    __privateAdd(this, _e);
+    __privateAdd(this, _t);
+    __privateSet(this, _e, e), __privateSet(this, _t, t);
+  }
+  on(e, t) {
+    return __privateGet(this, _t).subscribe(e, b, __privateGet(this, _e), t);
+  }
+  once(e, t) {
+    return __privateGet(this, _t).once(e, b, __privateGet(this, _e), t);
+  }
+  broadcast(e, ...t) {
+    __privateGet(this, _t).publish(e, __privateGet(this, _e), b, t);
+  }
+  from(e) {
+    return { subscribe: (t, n) => __privateGet(this, _t).subscribe(t, e, __privateGet(this, _e), n), once: (t, n) => __privateGet(this, _t).once(t, e, __privateGet(this, _e), n) };
+  }
+  to(e) {
+    return { publish: (t, ...n) => __privateGet(this, _t).publish(t, __privateGet(this, _e), e, n), publishAsync: (t, ...n) => __privateGet(this, _t).publishAsync(t, __privateGet(this, _e), e, n) };
+  }
+}, _e = new WeakMap(), _t = new WeakMap(), _a);
+var _e2, _t2, _n, _r_instances, r_fn, _r_static, _a2, i_fn, o_fn, s_fn;
+var w = (_a2 = class {
+  constructor({ onError: e = null } = {}) {
+    __privateAdd(this, _r_instances);
+    __privateAdd(this, _e2, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _t2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _n, null);
+    __privateSet(this, _n, e), this.createChannel(b);
+  }
+  static create(e = {}) {
+    return new _a2(e);
+  }
+  channel(e) {
+    return this.createChannel(e);
+  }
+  createChannel(e) {
+    if (__privateGet(this, _e2).has(e)) return __privateGet(this, _e2).get(e);
+    let t = new j(e, this);
+    return __privateGet(this, _e2).set(e, t), t;
+  }
+  subscribe(e, t, n, i) {
+    let s = { from: t, to: n, handler: i };
+    return __privateMethod(this, _r_instances, r_fn).call(this, e).add(s), () => {
+      let o = __privateGet(this, _t2).get(e);
+      o && o.delete(s);
+    };
+  }
+  once(e, t, n, i) {
+    let s = null, o = (c) => {
+      try {
+        i(c);
+      } finally {
+        s && s();
+      }
+    };
+    return s = this.subscribe(e, t, n, o), s;
+  }
+  offAllFor(e) {
+    for (let t of __privateGet(this, _t2).values()) for (let n of Array.from(t)) (n.from === e || n.to === e) && t.delete(n);
+  }
+  listenerCount(e) {
+    let t = __privateGet(this, _t2).get(e);
+    return t ? t.size : 0;
+  }
+  publish(e, t, n, i) {
+    __privateMethod(this, _r_instances, s_fn).call(this, e, t, n, i);
+  }
+  publishAsync(e, t, n, i) {
+    ae(() => __privateMethod(this, _r_instances, s_fn).call(this, e, t, n, i));
+  }
+  broadcast(e, t, n) {
+    this.publish(e, t, b, n);
+  }
+}, _e2 = new WeakMap(), _t2 = new WeakMap(), _n = new WeakMap(), _r_instances = new WeakSet(), r_fn = function(e) {
+  let t = __privateGet(this, _t2).get(e);
+  return t || (t = /* @__PURE__ */ new Set(), __privateGet(this, _t2).set(e, t)), t;
+}, _r_static = new WeakSet(), i_fn = function(e, t) {
+  return e === b || t === b || e === t;
+}, o_fn = function(e, t, n, i) {
+  var _a11, _b;
+  return __privateMethod(_a11 = _a2, _r_static, i_fn).call(_a11, e, n) && __privateMethod(_b = _a2, _r_static, i_fn).call(_b, t, i);
+}, s_fn = function(e, t, n, i) {
+  var _a11;
+  let s = __privateGet(this, _t2).get(e);
+  if (!(!s || s.size === 0)) {
+    for (let o of s) if (o.to !== t && __privateMethod(_a11 = _a2, _r_static, o_fn).call(_a11, t, n, o.from, o.to)) try {
+      o.handler(...i);
+    } catch (c) {
+      __privateGet(this, _n) && __privateGet(this, _n).call(this, c, { event: e, from: t, to: n, listener: o });
+    }
+  }
+}, __privateAdd(_a2, _r_static), _a2);
+var A = { trace: 10, debug: 20, info: 30, warn: 40, error: 50, silent: 90 };
+var _e3, _t3, _n2, _a3;
+var E = (_a3 = class {
+  constructor({ level: e = "info", sinks: t = [], base: n = {} } = {}) {
+    __privateAdd(this, _e3);
+    __privateAdd(this, _t3);
+    __privateAdd(this, _n2);
+    __privateSet(this, _e3, A[e] ?? A.info), __privateSet(this, _t3, t), __privateSet(this, _n2, n);
+  }
+  static create(e = {}) {
+    return new _a3(e);
+  }
+  setLevel(e) {
+    __privateSet(this, _e3, A[e] ?? __privateGet(this, _e3));
+  }
+  child(e = {}, t = []) {
+    return new _a3({ level: this.level, sinks: [...__privateGet(this, _t3), ...t], base: { ...__privateGet(this, _n2), ...e } });
+  }
+  get level() {
+    return Object.entries(A).find(([e, t]) => t === __privateGet(this, _e3))?.[0] ?? "info";
+  }
+  log(e, t, n = {}) {
+    if ((A[e] ?? A.info) < __privateGet(this, _e3)) return;
+    let s = { t: Date.now(), level: e, msg: t, ...__privateGet(this, _n2), ...n };
+    for (let o of __privateGet(this, _t3)) o(s);
+  }
+  trace(e, t) {
+    this.log("trace", e, t);
+  }
+  debug(e, t) {
+    this.log("debug", e, t);
+  }
+  info(e, t) {
+    this.log("info", e, t);
+  }
+  warn(e, t) {
+    this.log("warn", e, t);
+  }
+  error(e, t) {
+    this.log("error", e, t);
+  }
+  progress(e, t, n = "", i = {}) {
+    let s = { t: Date.now(), type: "progress", level: "info", msg: n, current: e, total: t, message: n, percentage: Math.round(e / t * 100), ...__privateGet(this, _n2), ...i };
+    for (let o of __privateGet(this, _t3)) o(s);
+  }
+  metric(e, t, n = "ms", i = {}) {
+    let s = { t: Date.now(), type: "metric", level: "info", msg: `${e}: ${t}${n}`, name: e, value: t, unit: n, ...__privateGet(this, _n2), ...i };
+    for (let o of __privateGet(this, _t3)) o(s);
+  }
+}, _e3 = new WeakMap(), _t3 = new WeakMap(), _n2 = new WeakMap(), _a3);
+var R = (r3) => {
+  let { t: e, level: t, msg: n, ns: i, ...s } = r3, o = new Date(e).toISOString(), c = t === "error" ? console.error : t === "warn" ? console.warn : console.log, l2 = `${i ? `[${i}] ` : ""}${n}`;
+  Object.keys(s).length > 0 ? c(`[${o}] ${t.toUpperCase()} ${l2}`, s) : c(`[${o}] ${t.toUpperCase()} ${l2}`);
+};
+var D = (r3 = 1e3) => {
+  let e = [];
+  return { sink: (t) => {
+    e.push(t), e.length > r3 && e.shift();
+  }, read: () => e.slice(), clear: () => {
+    e.length = 0;
+  } };
+};
+function F(r3, e, t = "value") {
+  if (Array.isArray(e)) {
+    for (let i of e) if (X(r3, i)) return true;
+    let n = e.map($).join(" | ");
+    throw new TypeError(`${t} must be one of: ${n}. Got ${$(r3)}`);
+  }
+  if (!X(r3, e)) throw new TypeError(`${t} must be ${$(e)}. Got ${$(r3)}`);
+  return true;
+}
+function X(r3, e) {
+  return e === String ? typeof r3 == "string" : e === Number ? typeof r3 == "number" && !isNaN(r3) : e === Boolean ? typeof r3 == "boolean" : e === Symbol ? typeof r3 == "symbol" : e === BigInt ? typeof r3 == "bigint" : e === Function ? typeof r3 == "function" : e === Array ? Array.isArray(r3) : e === Object ? r3 !== null && typeof r3 == "object" && !Array.isArray(r3) : r3 instanceof e;
+}
+function $(r3) {
+  return r3 === String ? "String" : r3 === Number ? "Number" : r3 === Boolean ? "Boolean" : r3 === Array ? "Array" : r3 === Object ? "Object" : r3 === Function ? "Function" : r3 === Date ? "Date" : r3 === RegExp ? "RegExp" : r3 === Promise ? "Promise" : r3 === Map ? "Map" : r3 === Set ? "Set" : r3 === WeakMap ? "WeakMap" : r3 === WeakSet ? "WeakSet" : r3 === Symbol ? "Symbol" : r3 === BigInt ? "BigInt" : r3 === Error ? "Error" : typeof r3 == "string" ? "string" : typeof r3 == "number" ? "number" : typeof r3 == "boolean" ? "boolean" : typeof r3 == "symbol" ? "symbol" : typeof r3 == "bigint" ? "bigint" : typeof r3 == "function" ? "function" : Array.isArray(r3) ? "Array" : r3 === null ? "null" : r3 === void 0 ? "undefined" : typeof r3 == "object" ? r3.constructor?.name || "Object" : "unknown";
+}
+function C(r3, e = "value") {
+  return (t) => F(t, r3, e);
+}
+var P = /* @__PURE__ */ new Map();
+var L = /* @__PURE__ */ new WeakMap();
+var x = (r3) => {
+  if (L.has(r3)) return L.get(r3);
+};
+var g = (r3, e = [], ...t) => {
+  let n = e.length > 0 ? C(e, "return value") : null;
+  if (P.has(r3)) return console.warn(`Definition type "${r3}" already exists`), P.get(r3);
+  let i = (...s) => {
+    if (s.length === 0) throw new Error("At least one argument is required");
+    let [o, c] = s, a = typeof o == "string" ? o : void 0, l2 = typeof o == "function" ? o : c;
+    C(Function, "factory")(l2);
+    let f = (...h) => {
+      try {
+        let u = l2.apply(null, [...h, ...t]);
+        if (n && u === void 0) throw new Error(`Factory ${r3} must return a value for ${a}`);
+        return n && n(u), u;
+      } catch (u) {
+        throw console.error(`Error creating definition "${a}"`, u), u;
+      }
+    };
+    return Object.defineProperty(f, "_name", { value: a, enumerable: false, configurable: false }), L.set(f, r3), f;
+  };
+  return P.set(r3, i), i;
+};
+var T = (r3) => r3 && r3.constructor && r3.constructor.name === "AsyncFunction";
+var V = (r3, e) => T(e) || r3.some(T);
+var _ = (r3, e) => e.length === 0 ? r3 : e.length === 1 && Array.isArray(e[0]) ? e[0] : e;
+var I = (r3) => r3 ? Array.isArray(r3) ? r3 : [r3] : [];
+var pe = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var ye = /* @__PURE__ */ new Set(["use", "install", "uninstall", "relay", "state", "debug"]);
+var k = 64;
+var te = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
+function ne(r3, e = "key") {
+  if (pe.has(r3)) throw new Error(`Illegal key "${r3}" in ${e}`);
+}
+function y(r3) {
+  if (ne(r3, "namespace"), typeof r3 != "string") throw new Error(`Namespace must be a string, got ${typeof r3}`);
+  if (!te.test(r3)) throw new Error(`Invalid namespace "${r3}". Must be a valid JS identifier`);
+  if (r3.length > k) throw new Error(`Namespace "${r3}" too long (max ${k} chars)`);
+  if (ye.has(r3)) throw new Error(`Namespace "${r3}" is reserved`);
+  return r3;
+}
+function re(r3) {
+  let e = r3?.manifest, t = e?.name ?? "<unknown service>";
+  if (!e?.namespace || typeof r3.install != "function") throw new Error(`${t} must have a namespace and install method`);
+  if (y(e.namespace), Object.prototype.hasOwnProperty.call(e, "default")) throw new Error(`Manifest for "${t}" has a "default" key \u2014 did you mean "defaults"?`);
+  if (e.defaults != null && (typeof e.defaults != "object" || Array.isArray(e.defaults))) throw new Error(`Manifest "defaults" for "${t}" must be a plain object`);
+  if (e.dependencies != null) {
+    if (!Array.isArray(e.dependencies)) throw new Error(`Manifest "dependencies" for "${t}" must be an array`);
+    for (let n of e.dependencies) if (!n?.manifest?.namespace || typeof n.install != "function") throw new Error(`Dependency of "${t}" is not an installable service (needs a manifest.namespace and install method)`);
+  }
+  return e;
+}
+function z(r3, e, t = "member") {
+  if (ne(r3, `${t}:${e}`), typeof r3 != "string") throw new Error(`${t} name in ${e} must be a string`);
+  if (!te.test(r3)) throw new Error(`Invalid ${t} name "${r3}" in ${e}`);
+  if (r3.length > k) throw new Error(`${t} name "${r3}" in ${e} too long (max ${k})`);
+  return r3;
+}
+function U(r3, e) {
+  if (!e || typeof e != "object") return e || r3;
+  if (!r3 || typeof r3 != "object") return e;
+  let t = { ...r3 };
+  for (let n in e) e.hasOwnProperty(n) && (e[n] && typeof e[n] == "object" && !Array.isArray(e[n]) && r3[n] && typeof r3[n] == "object" && !Array.isArray(r3[n]) ? t[n] = U(r3[n], e[n]) : t[n] = e[n]);
+  return t;
+}
+var B = () => {
+  let r3 = ["DEVELOPMENT", "TEST", "DEV"];
+  return typeof process < "u" && "production" ? r3.includes("production".toUpperCase()) : typeof globalThis < "u" && globalThis.__ENV__?.NODE_ENV ? r3.includes(globalThis.__ENV__.NODE_ENV.toUpperCase()) : false;
+};
+var O = (r3) => r3 != null && typeof r3.then == "function";
+var ie = /* @__PURE__ */ new Set();
+var _a4, _e4, _t4, _n3, _r, _i, _o, _s, _u, _f, _l, _d, _r_instances2, h_fn, w_fn, A_fn, E_fn, p_fn, x_fn, I_fn, T_fn, O_fn, M_fn, g_fn, S_fn, $_fn, C_fn, __fn, m_fn, y_fn, c_fn, b_fn, a_fn;
+var G = (_a4 = class {
+  constructor(e = {}, t = _a4.options) {
+    __privateAdd(this, _r_instances2);
+    __privateAdd(this, _e4, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _t4, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _n3, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _r, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _i, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _o, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _s);
+    __privateAdd(this, _u, {});
+    __privateAdd(this, _f);
+    __privateAdd(this, _l);
+    __privateAdd(this, _d);
+    __privateSet(this, _s, { ..._a4.options, ...t }), __privateSet(this, _u, { ...e });
+    for (let [n, i] of Object.entries(__privateGet(this, _u))) Object.defineProperty(this, n, { value: i, enumerable: true, configurable: false, writable: false });
+    __privateSet(this, _d, m.create()), __privateSet(this, _f, w.create()), __privateSet(this, _l, E.create({ level: B() ? "debug" : "info", sinks: [R, D(2e3).sink] }));
+  }
+  static create(e = {}) {
+    return new _a4(e, _a4.options);
+  }
+  static configure(e) {
+    return e = { ..._a4.options, ...e }, { create: (t = {}) => new _a4(t, e) };
+  }
+  get cache() {
+    return __privateGet(this, _d);
+  }
+  get relay() {
+    return __privateGet(this, _f);
+  }
+  get log() {
+    return __privateGet(this, _l);
+  }
+  use(...e) {
+    return __privateMethod(this, _r_instances2, p_fn).call(this, e, this);
+  }
+  install(...e) {
+    return __privateMethod(this, _r_instances2, h_fn).call(this, this, e, /* @__PURE__ */ new Set());
+  }
+  uninstall(...e) {
+    return __privateMethod(this, _r_instances2, E_fn).call(this, this, e);
+  }
+}, _e4 = new WeakMap(), _t4 = new WeakMap(), _n3 = new WeakMap(), _r = new WeakMap(), _i = new WeakMap(), _o = new WeakMap(), _s = new WeakMap(), _u = new WeakMap(), _f = new WeakMap(), _l = new WeakMap(), _d = new WeakMap(), _r_instances2 = new WeakSet(), h_fn = function(e, t, n = /* @__PURE__ */ new Set()) {
+  let i = [...t], s = () => {
+    for (; i.length > 0; ) {
+      let o = __privateMethod(this, _r_instances2, w_fn).call(this, e, i.shift(), n);
+      if (O(o)) return o.then(s);
+    }
+    return __privateMethod(this, _r_instances2, A_fn).call(this, e), e;
+  };
+  return s();
+}, w_fn = function(e, t, n) {
+  re(t);
+  let i = t.manifest.namespace;
+  if (n.has(i)) throw new Error(`Circular service dependency: ${[...n, i].join(" -> ")}`);
+  if (Object.prototype.hasOwnProperty.call(e, i)) throw new Error(`${i} already exists`);
+  let s = U(__privateGet(this, _s) || {}, t.config || t.manifest.defaults || {}), o = __privateMethod(this, _r_instances2, c_fn).call(this, e, i), c = __privateMethod(this, _r_instances2, b_fn).call(this, e, i, o, s, t.manifest);
+  n.add(i);
+  let a = () => {
+    let l2 = __privateMethod(this, _r_instances2, a_fn).call(this, e, i, o, s, t.manifest), f = t.install(l2, s);
+    if (O(f)) return f.then((h) => {
+      __privateMethod(this, _r_instances2, p_fn).call(this, h, e), n.delete(i);
+    });
+    __privateMethod(this, _r_instances2, p_fn).call(this, f, e), n.delete(i);
+  };
+  if (t.manifest.dependencies?.length) {
+    let l2 = t.manifest.dependencies.filter((u) => u.unique), f = t.manifest.dependencies.filter((u) => !u.unique && !Object.prototype.hasOwnProperty.call(e, u.manifest.namespace)), h;
+    if (l2.length > 0 && (h = __privateMethod(this, _r_instances2, h_fn).call(this, c, l2, n)), f.length > 0 && (h = O(h) ? h.then(() => __privateMethod(this, _r_instances2, h_fn).call(this, e, f, n)) : __privateMethod(this, _r_instances2, h_fn).call(this, e, f, n)), O(h)) return h.then(a);
+  }
+  return a();
+}, A_fn = function(e) {
+  let t = __privateGet(this, _i).get(e);
+  if (t?.size) {
+    for (let [n, i] of t) try {
+      i();
+    } finally {
+      t.delete(n);
+    }
+    __privateGet(this, _i).delete(e);
+  }
+}, E_fn = function(e, t) {
+  let n = __privateGet(this, _o).get(e), i = __privateGet(this, _e4).get(e), s = __privateGet(this, _t4).get(e), o = __privateMethod(this, _r_instances2, y_fn).call(this, e);
+  for (let c of t) {
+    n?.get(c)?.(), n?.delete(c);
+    let a = i?.get(c);
+    if (a && __privateGet(this, _f).offAllFor(a), o?.delete(c), __privateGet(this, _i).get(e)?.delete(c), __privateGet(this, _r).get(e)?.delete(c), Object.prototype.hasOwnProperty.call(e, c) && delete e[c], i?.delete(c), s?.delete(c), s) for (let l2 of s.values()) Object.prototype.hasOwnProperty.call(l2, c) && delete l2[c];
+  }
+  return n && n.size === 0 && __privateGet(this, _o).delete(e), this;
+}, p_fn = function(e, t = this) {
+  for (let n of e) if (n) switch (x(n)) {
+    case "MIDDLEWARE":
+      __privateMethod(this, _r_instances2, T_fn).call(this, n, t);
+      break;
+    case "GETTERS":
+      __privateMethod(this, _r_instances2, I_fn).call(this, n, t);
+      break;
+    case "ACTIONS":
+      __privateMethod(this, _r_instances2, x_fn).call(this, n, t);
+      break;
+    case "INITIALIZE":
+      __privateMethod(this, _r_instances2, O_fn).call(this, n, t);
+      break;
+    case "UNINSTALL":
+      __privateMethod(this, _r_instances2, M_fn).call(this, n, t);
+      break;
+    default:
+      throw new Error(`Unknown definition type: ${x(n)}`);
+  }
+  return this;
+}, x_fn = function(e, t = this) {
+  let n = y(e._name), i = __privateMethod(this, _r_instances2, c_fn).call(this, t, n), s = __privateMethod(this, _r_instances2, a_fn).call(this, t, n, i), o = e(s), c = __privateMethod(this, _r_instances2, y_fn).call(this, t).get(n) || [];
+  for (let [l2, f] of Object.entries(o)) {
+    if (l2 = z(l2, n, "action"), Object.prototype.hasOwnProperty.call(i, l2)) throw new Error(`Action "${n}.${l2}" already exists on this target`);
+    let h = __privateMethod(this, _r_instances2, S_fn).call(this, n, l2, f, i);
+    if (c.length === 0) {
+      i[l2] = h;
+      continue;
+    }
+    let u = __privateMethod(this, _r_instances2, $_fn).call(this, c, h);
+    i[l2] = (...d) => u(l2, { namespace: n, action: l2, args: d });
+  }
+  let a = __privateGet(this, _r).get(t);
+  return a || (a = /* @__PURE__ */ new Set(), __privateGet(this, _r).set(t, a)), a.add(n), __privateMethod(this, _r_instances2, g_fn).call(this, t, n, i);
+}, I_fn = function(e, t = this) {
+  let n = y(e._name), i = __privateMethod(this, _r_instances2, c_fn).call(this, t, n), s = __privateMethod(this, _r_instances2, a_fn).call(this, t, n, i), o = e(s);
+  for (let [c, a] of Object.entries(o)) {
+    z(c, n, "getter");
+    let l2 = a.bind(i);
+    Object.defineProperty(i, c, { get: () => l2(), enumerable: true, configurable: false });
+  }
+  return __privateMethod(this, _r_instances2, g_fn).call(this, t, n, i);
+}, T_fn = function(e, t = this) {
+  let n = y(e._name);
+  if (__privateGet(this, _r).get(t)?.has(n)) throw new Error(`Middleware for "${n}" must be installed before its actions (middleware does not apply retroactively)`);
+  let i = __privateMethod(this, _r_instances2, c_fn).call(this, t, n), s = __privateMethod(this, _r_instances2, a_fn).call(this, t, n, i), o = e(s), c = __privateMethod(this, _r_instances2, y_fn).call(this, t), a = c.get(n) || [], l2 = I(o).map((f) => {
+    if (typeof f != "function") throw new Error("Middleware must be a function");
+    return f;
+  });
+  return c.set(n, a.concat(l2)), this;
+}, O_fn = function(e, t = this) {
+  let n = y(e._name), i = __privateMethod(this, _r_instances2, c_fn).call(this, t, n), s = __privateMethod(this, _r_instances2, a_fn).call(this, t, n, i), o = () => e(s), c = __privateGet(this, _i).get(t);
+  return c || (c = /* @__PURE__ */ new Map(), __privateGet(this, _i).set(t, c)), c.set(n, o), this;
+}, M_fn = function(e, t = this) {
+  let n = y(e._name), i = __privateMethod(this, _r_instances2, c_fn).call(this, t, n), s = __privateMethod(this, _r_instances2, a_fn).call(this, t, n, i), o = () => e(s), c = __privateGet(this, _o).get(t);
+  return c || (c = /* @__PURE__ */ new Map(), __privateGet(this, _o).set(t, c)), c.set(n, o), this;
+}, g_fn = function(e, t, n) {
+  return Object.prototype.hasOwnProperty.call(e, t) ? n = e[t] : Object.defineProperty(e, t, { value: n, enumerable: true, configurable: true, writable: false }), __privateGet(this, _e4).get(e)?.set(t, n), e;
+}, S_fn = function(e, t, n, i) {
+  let s = n.bind(i), o = (c) => {
+    throw c.action = t, c.namespace = e, __privateGet(this, _l).error(`Error in action "${e}.${t}"`, { error: c }), c;
+  };
+  return T(s) ? async (...c) => {
+    try {
+      return await s(...c);
+    } catch (a) {
+      o(a);
+    }
+  } : (...c) => {
+    try {
+      return s(...c);
+    } catch (a) {
+      o(a);
+    }
+  };
+}, $_fn = function(e, t) {
+  return V(I(e), t) ? __privateMethod(this, _r_instances2, __fn).call(this, e, t) : __privateMethod(this, _r_instances2, C_fn).call(this, e, t);
+}, C_fn = function(e, t) {
+  let n = I(e);
+  return (i, s) => {
+    let o = -1, c = (a, l2) => {
+      if (a <= o) throw new Error("next() called multiple times");
+      o = a;
+      let f = n[a];
+      if (!f) {
+        let u = t(...l2);
+        if (B() && O(u)) {
+          let d = `${s.namespace}.${i}`;
+          ie.has(d) || (ie.add(d), __privateGet(this, _l).warn(`Action "${d}" returned a Promise but is not declared async; its middleware composes synchronously, so code after next() runs before the action settles. Declare the action async to compose the chain asynchronously.`));
+        }
+        return u;
+      }
+      let h = { ...s, args: l2 };
+      return __privateMethod(this, _r_instances2, m_fn).call(this, f, i, h, (...u) => {
+        let d = _(l2, u);
+        return c(a + 1, d);
+      });
+    };
+    return c(0, s.args);
+  };
+}, __fn = function(e, t) {
+  let n = I(e);
+  return async (i, s) => {
+    let o = -1, c = async (a, l2) => {
+      if (a <= o) throw new Error("next() called multiple times");
+      o = a;
+      let f = n[a];
+      if (!f) return await t(...l2);
+      let h = { ...s, args: l2 };
+      return await __privateMethod(this, _r_instances2, m_fn).call(this, f, i, h, (...u) => {
+        let d = _(l2, u);
+        return c(a + 1, d);
+      });
+    };
+    return c(0, s.args);
+  };
+}, m_fn = function(e, t, n, i) {
+  try {
+    return e(t, n, i);
+  } catch (s) {
+    throw s.middleware = e.name || "<anon>", s.action = t, s;
+  }
+}, y_fn = function(e) {
+  let t = __privateGet(this, _n3).get(e);
+  return t || (t = /* @__PURE__ */ new Map(), __privateGet(this, _n3).set(e, t)), t;
+}, c_fn = function(e, t) {
+  let n = __privateGet(this, _e4).get(e);
+  if (n || (n = /* @__PURE__ */ new Map(), __privateGet(this, _e4).set(e, n)), n.has(t)) return n.get(t);
+  let i = /* @__PURE__ */ Object.create(null);
+  return n.set(t, i), i;
+}, b_fn = function(e, t, n, i = __privateGet(this, _s) || {}, s = {}) {
+  let o = __privateGet(this, _t4).get(e);
+  if (o || (o = /* @__PURE__ */ new Map(), __privateGet(this, _t4).set(e, o)), o.has(t)) return o.get(t);
+  let c = { ...__privateGet(this, _u), log: __privateGet(this, _l).child({ ns: t }, s.log?.sinks || []), relay: __privateGet(this, _f).createChannel(n), cache: __privateGet(this, _d), config: i }, a = new Proxy(c, { get(l2, f, h) {
+    return f in l2 ? Reflect.get(l2, f, h) : Reflect.get(e, f, h);
+  }, has(l2, f) {
+    return f in l2 || f in e;
+  } });
+  return o.set(t, a), a;
+}, a_fn = function(e, t, n, i = __privateGet(this, _s) || {}, s = {}) {
+  return (...o) => {
+    let c = __privateMethod(this, _r_instances2, b_fn).call(this, e, t, n, i, s);
+    if (!o || o.length === 0) return c;
+    if (o.length === 1) return c[o[0]];
+    let a = new Array(o.length);
+    for (let l2 = 0; l2 < o.length; l2++) a[l2] = c[o[l2]];
+    return a;
+  };
+}, __publicField(_a4, "options", {}), _a4);
+var W = g("MIDDLEWARE", [Function, Array]);
+var q = g("ACTIONS", [Object]);
+var Y = g("UNINSTALL");
+var Z = g("INITIALIZE");
+var J = g("GETTERS", [Object]);
+var _e5, _t5, _n4, _r_instances3, r_fn2, _a5;
+var N = (_a5 = class {
+  constructor(e) {
+    __privateAdd(this, _r_instances3);
+    __privateAdd(this, _e5);
+    __privateAdd(this, _t5);
+    __privateAdd(this, _n4, { MIDDLEWARE: null, GETTERS: null, ACTIONS: null, INITIALIZE: null, UNINSTALL: null });
+    __publicField(this, "defineMiddleware", (e) => __privateMethod(this, _r_instances3, r_fn2).call(this, "MIDDLEWARE", e, W));
+    __publicField(this, "defineGetters", (e) => __privateMethod(this, _r_instances3, r_fn2).call(this, "GETTERS", e, J));
+    __publicField(this, "defineActions", (e) => __privateMethod(this, _r_instances3, r_fn2).call(this, "ACTIONS", e, q));
+    __publicField(this, "defineInitialize", (e) => __privateMethod(this, _r_instances3, r_fn2).call(this, "INITIALIZE", e, Z));
+    __publicField(this, "defineUninstall", (e) => __privateMethod(this, _r_instances3, r_fn2).call(this, "UNINSTALL", e, Y));
+    __privateSet(this, _e5, e);
+  }
+  static create(e) {
+    return new _a5(e);
+  }
+  _toArray() {
+    return [__privateGet(this, _n4).MIDDLEWARE, __privateGet(this, _n4).GETTERS, __privateGet(this, _n4).ACTIONS, __privateGet(this, _n4).INITIALIZE, __privateGet(this, _n4).UNINSTALL].filter(Boolean);
+  }
+}, _e5 = new WeakMap(), _t5 = new WeakMap(), _n4 = new WeakMap(), _r_instances3 = new WeakSet(), r_fn2 = function(e, t, n) {
+  if (__privateGet(this, _n4)[e]) throw new Error(`${e} already defined for ${__privateGet(this, _e5)}`);
+  __privateGet(this, _n4)[e] = n(__privateGet(this, _e5), t);
+}, _a5);
+var _a6;
+var v = (_a6 = class {
+  static configure(e = {}) {
+    return { install: (t, n) => this.install(t, n), manifest: this.manifest, config: { ...this.config || this.manifest.defaults || {}, ...e }, unique: true, configured: true };
+  }
+  static install(e, t) {
+    let { namespace: n } = this.manifest;
+    y(n);
+    let i = new this();
+    Object.defineProperty(i, "config", { value: Object.freeze({ ...t }), writable: false, configurable: false, enumerable: false }), Object.defineProperty(i, "inject", { value: (...o) => e(...o), writable: false, configurable: false, enumerable: false });
+    let s = N.create(n);
+    if (i.setup) {
+      let o = { defineActions: (a) => s.defineActions(() => a(e, t)), defineMiddleware: (a) => s.defineMiddleware(() => a(e, t)), defineGetters: (a) => s.defineGetters(() => a(e, t)), defineInitialize: (a) => s.defineInitialize(() => a(e, t)), defineUninstall: (a) => s.defineUninstall(() => a(e, t)) }, c = i.setup(o);
+      return c?.then ? c.then(() => s._toArray()) : s._toArray();
+    }
+    return i.middleware && s.defineMiddleware(() => i.middleware(e, t)), i.getters && s.defineGetters(() => i.getters(e, t)), i.actions && s.defineActions(() => i.actions(e, t)), i.initialize && s.defineInitialize(() => i.initialize(e, t)), i.uninstall && s.defineUninstall(() => i.uninstall(e, t)), s._toArray();
+  }
+}, __publicField(_a6, "manifest", { name: "base", dependencies: [], version: "1.0.0", description: "Base extension template" }), __publicField(_a6, "config", null), __publicField(_a6, "unique", false), _a6);
+var M = Symbol("jucie.engine");
+
+// ../../node_modules/nanoid/index.browser.js
+var nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+  byte &= 63;
+  if (byte < 36) {
+    id += byte.toString(36);
+  } else if (byte < 62) {
+    id += (byte - 26).toString(36).toUpperCase();
+  } else if (byte > 62) {
+    id += "-";
+  } else {
+    id += "_";
+  }
+  return id;
+}, "");
+
+// ../../node_modules/@jucie.io/engine-message/dist/main.js
+var b2 = ((i) => typeof __require < "u" ? __require : typeof Proxy < "u" ? new Proxy(i, { get: (e, t) => (typeof __require < "u" ? __require : e)[t] }) : i)(function(i) {
+  if (typeof __require < "u") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + i + '" is not supported');
+});
+var A2 = (i, e) => setTimeout(() => {
+  i(new Error("Timeout waiting for connect"));
+}, e);
+function w2(i) {
+  return i != null && typeof i.postMessage == "function";
+}
+function P2(i) {
+  return typeof i?.on == "function" && typeof i?.removeListener == "function" && !("onmessage" in i);
+}
+function v2(i) {
+  return i != null && typeof i == "object" && "data" in i ? { data: i.data } : { data: i };
+}
+function N2(i) {
+  if (!i || !P2(i)) return i;
+  let e = null, t = null, r3 = null, s = (n, o) => {
+    if (o) try {
+      i.removeListener(n, o);
+    } catch {
+    }
+    return null;
+  };
+  return { postMessage(...n) {
+    return i.postMessage(...n);
+  }, start() {
+    typeof i.start == "function" && i.start();
+  }, close() {
+    e = s("message", e), t = s("error", t), r3 = s("close", r3), typeof i.close == "function" && i.close();
+  }, set onmessage(n) {
+    e = s("message", e), typeof n == "function" && (e = (o) => n(v2(o)), i.on("message", e));
+  }, get onmessage() {
+    return e;
+  }, set onerror(n) {
+    t = s("error", t), typeof n == "function" && (t = n, i.on("error", t));
+  }, get onerror() {
+    return t;
+  }, set onclose(n) {
+    r3 = s("close", r3), typeof n == "function" && (r3 = n, i.on("close", r3));
+  }, get onclose() {
+    return r3;
+  } };
+}
+var _a7, _e6, _t6, _i2, _a8, _s2, _n5, _r2, _h, _i_instances, c_fn2, E_fn2, o_fn2, p_fn2, u_fn, l_fn, f_fn, d_fn, S_fn2, w_fn2, m_fn2, g_fn2;
+var p2 = (_a7 = class {
+  constructor(e, t = nanoid(), r3 = {}) {
+    __privateAdd(this, _i_instances);
+    __privateAdd(this, _e6, null);
+    __privateAdd(this, _t6, false);
+    __privateAdd(this, _i2, null);
+    __privateAdd(this, _a8, false);
+    __privateAdd(this, _s2, null);
+    __privateAdd(this, _n5, /* @__PURE__ */ new Map());
+    __privateAdd(this, _r2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _h, 1e3);
+    if (__privateSet(this, _h, r3.timeoutMs ?? 1e3), e = N2(e), e) {
+      if (typeof e.postMessage != "function") throw new Error("Port must be an object with postMessage");
+      __privateSet(this, _e6, e), __privateSet(this, _i2, t), __privateGet(this, _e6).onmessage = (s) => __privateMethod(this, _i_instances, f_fn).call(this, s), __privateGet(this, _e6).onerror = (s) => __privateMethod(this, _i_instances, g_fn2).call(this, s), __privateMethod(this, _i_instances, o_fn2).call(this), __privateSet(this, _t6, true), typeof __privateGet(this, _e6).start == "function" && __privateGet(this, _e6).start();
+    }
+  }
+  static get EVENTS() {
+    return { CONNECT: "CONNECT", CONFIRM_CONNECT: "CONFIRM_CONNECT", DISCONNECT: "DISCONNECT", RESPONSE: "RESPONSE", ENABLE: "ENABLE", ERROR: "ERROR", MESSAGE: "MESSAGE", GATHER: "GATHER", WARNING: "WARNING", INFO: "INFO", DEBUG: "DEBUG", TRACE: "TRACE" };
+  }
+  get enabled() {
+    return __privateGet(this, _t6);
+  }
+  static connect({ port: e, options: t = {} }) {
+    t = { ..._a7.defaultOptions, ...t }, e = N2(e);
+    let r3 = nanoid();
+    return new Promise((s, n) => {
+      let o = 0, c = null, a = false, u = () => {
+        c && clearTimeout(c);
+        try {
+          e.onmessage = null;
+        } catch {
+        }
+        try {
+          e.onerror = null;
+        } catch {
+        }
+      };
+      if (t.primary) {
+        if (e.onmessage = (h) => {
+          let d = h?.data;
+          if (!Array.isArray(d) || d.length < 2) return;
+          let [E2, f] = d;
+          if (E2 === _a7.EVENTS.CONNECT) try {
+            e.postMessage([_a7.EVENTS.CONFIRM_CONNECT, { rid: f?.rid, sid: f?.sid }]), a = true, u(), s(new _a7(e, f?.sid, { timeoutMs: t.timeoutMs }));
+          } catch (m2) {
+            u(), n(m2);
+          }
+        }, e.onerror = (h) => {
+          a || (a = true, u(), n(h));
+        }, typeof e.start == "function") try {
+          e.start();
+        } catch {
+        }
+      } else {
+        let h = () => {
+          if (o >= t.maxRetries) {
+            a || (u(), n(new Error("Max retries reached")));
+            return;
+          }
+          let E2 = Math.min(t.baseDelay * 2 ** o, t.maxDelay), f = Math.floor(E2 * t.jitter * Math.random());
+          c = setTimeout(d, E2 + f);
+        }, d = () => {
+          o += 1;
+          try {
+            e.postMessage([_a7.EVENTS.CONNECT, { rid: nanoid(), sid: r3 }]);
+          } catch (E2) {
+            u(), n(E2);
+            return;
+          }
+          h();
+        };
+        if (e.onmessage = (E2) => {
+          let f = E2?.data;
+          if (!Array.isArray(f) || f.length < 2) return;
+          let [m2, S2] = f;
+          if (!(!S2?.sid || !S2?.rid)) switch (m2) {
+            case _a7.EVENTS.CONFIRM_CONNECT: {
+              if (a) return;
+              a = true, u(), s(new _a7(e, S2?.sid, { timeoutMs: t.timeoutMs }));
+              break;
+            }
+            case _a7.EVENTS.ERROR: {
+              if (a) return;
+              a = true, u(), n(new Error("Handshake error"));
+              break;
+            }
+            default:
+              break;
+          }
+        }, e.onerror = (E2) => {
+          a || (a = true, u(), n(E2));
+        }, typeof e.start == "function") try {
+          e.start();
+        } catch {
+        }
+        d();
+      }
+    });
+  }
+  get sid() {
+    return __privateGet(this, _i2);
+  }
+  close() {
+    __privateGet(this, _a8) || (__privateSet(this, _a8, true), console.warn(`[Port] close() \u2014 sid: ${__privateGet(this, _i2)}, pending: ${__privateGet(this, _n5).size}, enabled: ${__privateGet(this, _t6)}`), __privateMethod(this, _i_instances, m_fn2).call(this, _a7.EVENTS.DISCONNECT, { sid: __privateGet(this, _i2) }), __privateMethod(this, _i_instances, E_fn2).call(this));
+  }
+  emit(e) {
+    return __privateGet(this, _e6) ? __privateGet(this, _t6) ? __privateMethod(this, _i_instances, u_fn).call(this, e) : Promise.resolve(null) : Promise.reject(new Error("No port available"));
+  }
+  request(e, t) {
+    return __privateGet(this, _e6) ? __privateGet(this, _t6) ? __privateMethod(this, _i_instances, l_fn).call(this, _a7.EVENTS.MESSAGE, e, t) : Promise.resolve(null) : Promise.reject(new Error("No port available"));
+  }
+  gather(e, t) {
+    return __privateGet(this, _e6) ? __privateGet(this, _t6) ? __privateMethod(this, _i_instances, l_fn).call(this, _a7.EVENTS.GATHER, e, t) : Promise.resolve(null) : Promise.reject(new Error("No port available"));
+  }
+  async enable() {
+    return __privateGet(this, _e6) ? (__privateSet(this, _t6, await __privateMethod(this, _i_instances, l_fn).call(this, _a7.EVENTS.ENABLE, true)), __privateGet(this, _t6)) : Promise.reject(new Error("No port available"));
+  }
+  async disable() {
+    return __privateGet(this, _e6) ? (__privateSet(this, _t6, await __privateMethod(this, _i_instances, l_fn).call(this, _a7.EVENTS.ENABLE, false)), __privateGet(this, _t6)) : Promise.reject(new Error("No port available"));
+  }
+  onMessage(e) {
+    if (typeof e != "function") throw new Error("Listener must be a function");
+    if (__privateGet(this, _r2).has(_a7.EVENTS.MESSAGE)) throw new Error("A listener is already registered. Remove the existing listener before adding a new one.");
+    return __privateGet(this, _r2).set(_a7.EVENTS.MESSAGE, e), () => {
+      __privateGet(this, _r2).get(_a7.EVENTS.MESSAGE) === e && __privateGet(this, _r2).delete(_a7.EVENTS.MESSAGE);
+    };
+  }
+  onEnable(e) {
+    if (typeof e != "function") throw new Error("Listener must be a function");
+    return __privateGet(this, _r2).set(_a7.EVENTS.ENABLE, e), () => __privateGet(this, _r2).delete(_a7.EVENTS.ENABLE);
+  }
+  onError(e) {
+    if (typeof e != "function") throw new Error("Listener must be a function");
+    if (__privateGet(this, _r2).has(_a7.EVENTS.ERROR)) throw new Error("A listener is already registered. Remove the existing listener before adding a new one.");
+    return __privateGet(this, _r2).set(_a7.EVENTS.ERROR, e), () => __privateGet(this, _r2).delete(_a7.EVENTS.ERROR);
+  }
+  onDisconnect(e) {
+    if (typeof e != "function") throw new Error("Listener must be a function");
+    return __privateGet(this, _r2).set(_a7.EVENTS.DISCONNECT, e), () => __privateGet(this, _r2).delete(_a7.EVENTS.DISCONNECT);
+  }
+}, _e6 = new WeakMap(), _t6 = new WeakMap(), _i2 = new WeakMap(), _a8 = new WeakMap(), _s2 = new WeakMap(), _n5 = new WeakMap(), _r2 = new WeakMap(), _h = new WeakMap(), _i_instances = new WeakSet(), c_fn2 = function(e) {
+  if (__privateGet(this, _a8)) return;
+  __privateSet(this, _a8, true), console.warn(`[Port] disconnect detected \u2014 sid: ${__privateGet(this, _i2)}, reason: ${e}`);
+  let t = __privateGet(this, _r2).get(_a7.EVENTS.DISCONNECT);
+  if (__privateMethod(this, _i_instances, E_fn2).call(this), t) try {
+    t(e);
+  } catch (r3) {
+    console.error("Port onDisconnect listener error:", r3);
+  }
+}, E_fn2 = function() {
+  __privateGet(this, _e6) && (__privateMethod(this, _i_instances, p_fn2).call(this), __privateGet(this, _e6).onmessage = null, __privateGet(this, _e6).onerror = null, typeof __privateGet(this, _e6).stop == "function" && __privateGet(this, _e6).stop(), typeof __privateGet(this, _e6).close == "function" && __privateGet(this, _e6).close());
+  for (let [e, t] of __privateGet(this, _n5)) console.warn(`[Port] rejecting pending rid=${e}`), t.timeout && clearTimeout(t.timeout), t.reject?.(new Error("Port closed"));
+  __privateGet(this, _n5).clear(), __privateSet(this, _e6, null), __privateSet(this, _t6, false), __privateGet(this, _r2).clear();
+}, o_fn2 = function() {
+  let e = __privateGet(this, _e6);
+  if (!e) return;
+  let t = () => __privateMethod(this, _i_instances, c_fn2).call(this, "peer-lost");
+  try {
+    "onclose" in e ? e.onclose = t : typeof e.addEventListener == "function" ? (e.addEventListener("close", t), __privateSet(this, _s2, t)) : typeof e.on == "function" && (e.on("close", t), __privateSet(this, _s2, t));
+  } catch {
+  }
+}, p_fn2 = function() {
+  let e = __privateGet(this, _e6);
+  if (e) try {
+    __privateGet(this, _s2) ? (typeof e.removeEventListener == "function" ? e.removeEventListener("close", __privateGet(this, _s2)) : typeof e.removeListener == "function" && e.removeListener("close", __privateGet(this, _s2)), __privateSet(this, _s2, null)) : "onclose" in e && (e.onclose = null);
+  } catch {
+  }
+}, u_fn = function(e) {
+  try {
+    return __privateMethod(this, _i_instances, m_fn2).call(this, _a7.EVENTS.MESSAGE, { sid: __privateGet(this, _i2), rid: null, payload: e });
+  } catch (t) {
+    return Promise.reject(t);
+  }
+}, l_fn = function(e, t, r3 = __privateGet(this, _h)) {
+  return new Promise((s, n) => {
+    try {
+      let o = nanoid(), c = A2(() => {
+        __privateGet(this, _n5).delete(o);
+        let a = Array.isArray(t) ? t[1] : e;
+        console.warn(`[Port] request TIMEOUT \u2014 sid: ${__privateGet(this, _i2)}, rid: ${o}, event: ${a}, ms: ${r3}`), n(new Error("Request timeout"));
+      }, r3);
+      __privateGet(this, _n5).set(o, { resolve: s, reject: n, timeout: c }), __privateMethod(this, _i_instances, m_fn2).call(this, e, { sid: __privateGet(this, _i2), rid: o, payload: t });
+    } catch (o) {
+      n(o);
+    }
+  });
+}, f_fn = function(e) {
+  let t = e?.data;
+  if (!Array.isArray(t) || t.length < 2) return;
+  let [r3, s] = t || [];
+  if (!(s?.sid && s.sid !== __privateGet(this, _i2))) switch (r3) {
+    case _a7.EVENTS.RESPONSE:
+      __privateMethod(this, _i_instances, S_fn2).call(this, s?.rid, s?.payload, "resolve");
+      return;
+    case _a7.EVENTS.ERROR:
+      let n = s?.payload instanceof Error ? s.payload.message : String(s?.payload);
+      __privateMethod(this, _i_instances, S_fn2).call(this, s?.rid, new Error(n), "reject");
+      return;
+    case _a7.EVENTS.MESSAGE:
+      __privateMethod(this, _i_instances, d_fn).call(this, s?.rid, s?.payload, false);
+      return;
+    case _a7.EVENTS.GATHER:
+      __privateMethod(this, _i_instances, d_fn).call(this, s?.rid, s?.payload, true);
+      return;
+    case _a7.EVENTS.ENABLE:
+      __privateMethod(this, _i_instances, w_fn2).call(this, s?.rid, s?.payload);
+      return;
+    case _a7.EVENTS.DISCONNECT:
+      __privateMethod(this, _i_instances, c_fn2).call(this, "closed");
+      return;
+    default:
+      return;
+  }
+}, d_fn = async function(e, t, r3 = false) {
+  try {
+    let s = __privateGet(this, _r2).get(_a7.EVENTS.MESSAGE), n = s ? await s(t, { isRequest: !!e, isGather: r3 }) : null;
+    return e ? __privateMethod(this, _i_instances, m_fn2).call(this, _a7.EVENTS.RESPONSE, { rid: e, payload: n ?? null }) : void 0;
+  } catch (s) {
+    let n = s instanceof Error ? s.message : String(s);
+    __privateMethod(this, _i_instances, m_fn2).call(this, _a7.EVENTS.ERROR, { rid: e, payload: n });
+  }
+}, S_fn2 = function(e, t, r3) {
+  let s = __privateGet(this, _n5).get(e);
+  s && (s.timeout && clearTimeout(s.timeout), __privateGet(this, _n5).delete(e), r3 === "resolve" ? s.resolve(t) : s.reject(t));
+}, w_fn2 = function(e, t) {
+  __privateSet(this, _t6, t);
+  let r3 = __privateGet(this, _r2).get(_a7.EVENTS.ENABLE);
+  return r3 && r3(t), __privateMethod(this, _i_instances, m_fn2).call(this, _a7.EVENTS.RESPONSE, { rid: e, payload: t });
+}, m_fn2 = function(e, t) {
+  if (!__privateGet(this, _e6)) return console.warn(`[Port] #postMessage but port is null \u2014 type: ${e}, sid: ${__privateGet(this, _i2)}`), false;
+  try {
+    __privateGet(this, _e6).postMessage([e, t]);
+  } catch (r3) {
+    return console.error(`[Port] #postMessage FAILED \u2014 type: ${e}, sid: ${__privateGet(this, _i2)}`, r3.message), r3?.name !== "DataCloneError" && __privateMethod(this, _i_instances, c_fn2).call(this, "peer-lost"), false;
+  }
+  return true;
+}, g_fn2 = function(e) {
+  console.error("onerror", e);
+}, __publicField(_a7, "defaultOptions", { primary: false, maxRetries: 10, baseDelay: 200, maxDelay: 2e3, jitter: 0.2, timeoutMs: 1e3 }), _a7);
+var l = { HANDSHAKE: "HANDSHAKE", MESSAGE: "MESSAGE", GATHER: "GATHER", SUBSCRIBE: "SUBSCRIBE", UNSUBSCRIBE: "UNSUBSCRIBE", SYNC: "SYNC" };
+var L2 = g("channelContracts", [Object]);
+var _e7, _t7, _i3, _a9, _s3, _n6, _r3, _h2, _c, _E, _o2, _a10, _T_instances, p_fn3, u_fn2, l_fn2, f_fn2, d_fn2, S_fn3, w_fn3, _m, _g, _y, b_fn2, N_fn, C_fn2;
+var T2 = (_a10 = class extends v {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _T_instances);
+    __privateAdd(this, _e7, null);
+    __privateAdd(this, _t7, null);
+    __privateAdd(this, _i3, 1e3);
+    __privateAdd(this, _a9, /* @__PURE__ */ new Map());
+    __privateAdd(this, _s3, /* @__PURE__ */ new Map());
+    __privateAdd(this, _n6, []);
+    __privateAdd(this, _r3, false);
+    __privateAdd(this, _h2, null);
+    __privateAdd(this, _c, false);
+    __privateAdd(this, _E, null);
+    __privateAdd(this, _o2, { enable: /* @__PURE__ */ new Set(), disable: /* @__PURE__ */ new Set(), connect: /* @__PURE__ */ new Set(), disconnect: /* @__PURE__ */ new Set() });
+    __privateAdd(this, _m, async ([e, t, r3, s, n]) => {
+      let o = [];
+      switch (e) {
+        case l.MESSAGE:
+          let c = __privateGet(this, _s3).get(t);
+          if (c) for (let a of c) {
+            if (!__privateMethod(this, _T_instances, C_fn2).call(this, t, r3, a.schema)) continue;
+            let u = await a.subscriber(...r3);
+            o.push(u), a.once && __privateGet(this, _s3).get(t).delete(a);
+          }
+          break;
+        case l.SUBSCRIBE:
+        case l.UNSUBSCRIBE:
+          r3 != null ? __privateGet(this, _a9).set(t, r3) : __privateGet(this, _a9).delete(t);
+          break;
+      }
+      return o.length > 0 ? o[0] : null;
+    });
+    __privateAdd(this, _g, (e, t, r3) => {
+      switch (e) {
+        case "ENABLE":
+          t === true ? __privateGet(this, _o2).enable.forEach((s) => s(r3)) : __privateGet(this, _o2).disable.forEach((s) => s(r3));
+          break;
+        case "CONNECT":
+          __privateGet(this, _o2).connect.forEach((s) => s(r3));
+          break;
+      }
+    });
+    __privateAdd(this, _y, (e) => {
+      console.error("Channel error:", e);
+    });
+  }
+  initialize(e, t) {
+    if (t.port != null && !w2(t.port)) throw new Error("Configured port must have postMessage");
+    if (__privateSet(this, _t7, t.port), __privateSet(this, _i3, t.timeout ?? 1e3), t.subscriptions && t.subscriptions.length) for (let r3 of t.subscriptions) __privateGet(this, _n6).push(r3);
+  }
+  actions() {
+    let e = { ready: () => __privateGet(this, _r3), portProvider: (t) => {
+      if (typeof t != "function") throw new Error("portProvider must be a function");
+      return __privateSet(this, _h2, t), e;
+    }, connect: async (t, r3) => {
+      try {
+        if (__privateSet(this, _t7, t ?? __privateGet(this, _t7)), !w2(__privateGet(this, _t7))) throw new Error("Message port is required");
+        if (r3 && typeof r3 == "function" && __privateGet(this, _o2).connect.add(r3), __privateGet(this, _e7)) {
+          let n = __privateGet(this, _e7);
+          __privateSet(this, _e7, null), __privateSet(this, _r3, false), n.close();
+        }
+        __privateSet(this, _e7, await p2.connect({ port: __privateGet(this, _t7), options: { timeoutMs: __privateGet(this, _i3) } }));
+        let s = __privateGet(this, _e7);
+        s.onMessage(async (n) => await __privateGet(this, _m).call(this, n)), s.onEnable((n) => __privateGet(this, _g).call(this, "ENABLE", n, e)), s.onError(__privateGet(this, _y)), s.onDisconnect((n) => {
+          __privateGet(this, _e7) === s && __privateMethod(this, _T_instances, b_fn2).call(this, n);
+        }), __privateSet(this, _r3, true);
+        for (let [n, o] of __privateGet(this, _s3)) {
+          let c;
+          for (let a of o) a.timeoutMs !== void 0 && (c === void 0 || a.timeoutMs > c) && (c = a.timeoutMs);
+          __privateGet(this, _e7).emit([l.SUBSCRIBE, n, c]);
+        }
+        if (__privateGet(this, _n6).length > 0) {
+          let n = __privateGet(this, _n6);
+          __privateSet(this, _n6, []);
+          for (let o of n) __privateMethod(this, _T_instances, p_fn3).call(this, o);
+        }
+        return await __privateMethod(this, _T_instances, w_fn3).call(this), __privateGet(this, _g).call(this, "CONNECT", true, e), e;
+      } catch (s) {
+        return console.error("Channel error:", s), false;
+      }
+    }, onEnable: (t) => {
+      if (typeof t != "function") throw new Error("Listener must be a function");
+      return __privateGet(this, _o2).enable.add(t), () => __privateGet(this, _o2).enable.delete(t);
+    }, onDisable: (t) => {
+      if (typeof t != "function") throw new Error("Listener must be a function");
+      return __privateGet(this, _o2).disable.add(t), () => __privateGet(this, _o2).disable.delete(t);
+    }, onDisconnect: (t) => {
+      if (typeof t != "function") throw new Error("Listener must be a function");
+      return __privateGet(this, _o2).disconnect.add(t), () => __privateGet(this, _o2).disconnect.delete(t);
+    }, disconnect: () => {
+      if (__privateGet(this, _e7)) {
+        __privateGet(this, _o2).disconnect.forEach((t) => t("closed", e));
+        for (let t of __privateGet(this, _s3).keys()) __privateGet(this, _e7).emit([l.UNSUBSCRIBE, t]);
+        __privateGet(this, _e7).close(), __privateSet(this, _e7, null), __privateSet(this, _r3, false), __privateGet(this, _s3).clear(), __privateGet(this, _a9).clear(), __privateSet(this, _n6, []);
+      }
+    }, use: (...t) => {
+      if (__privateGet(this, _r3)) {
+        for (let r3 of t) __privateMethod(this, _T_instances, p_fn3).call(this, r3);
+        return e;
+      }
+      for (let r3 of t) __privateGet(this, _n6).push(r3);
+      return e;
+    }, publish: (t, ...r3) => (__privateMethod(this, _T_instances, f_fn2).call(this, l.MESSAGE, t, r3), e), request: (t, ...r3) => __privateMethod(this, _T_instances, d_fn2).call(this, l.MESSAGE, t, r3), gather: (t, ...r3) => __privateMethod(this, _T_instances, S_fn3).call(this, l.GATHER, t, r3), subscribe: (t, r3) => __privateMethod(this, _T_instances, u_fn2).call(this, t, void 0, r3, false), subscribeOnce: (t, r3) => __privateMethod(this, _T_instances, u_fn2).call(this, t, void 0, r3, true), unsubscribe: (t, r3) => __privateMethod(this, _T_instances, l_fn2).call(this, t, r3), to: (...t) => ({ publish: (r3, ...s) => {
+      __privateMethod(this, _T_instances, f_fn2).call(this, l.MESSAGE, r3, s, t);
+    }, request: (r3, ...s) => __privateMethod(this, _T_instances, d_fn2).call(this, l.MESSAGE, r3, s, t), gather: (r3, ...s) => __privateMethod(this, _T_instances, S_fn3).call(this, l.GATHER, r3, s, t) }), namespace: (t) => ({ publish: (r3, ...s) => {
+      let n = t ? `${t}/${r3}` : r3;
+      return __privateMethod(this, _T_instances, f_fn2).call(this, l.MESSAGE, n, s), e;
+    }, request: (r3, ...s) => {
+      let n = t ? `${t}/${r3}` : r3;
+      return __privateMethod(this, _T_instances, d_fn2).call(this, l.MESSAGE, n, s);
+    }, gather: (r3, ...s) => {
+      let n = t ? `${t}/${r3}` : r3;
+      return __privateMethod(this, _T_instances, S_fn3).call(this, l.GATHER, n, s);
+    }, subscribe: (r3, s) => {
+      let n = t ? `${t}/${r3}` : r3;
+      return __privateMethod(this, _T_instances, u_fn2).call(this, n, void 0, s, false), e;
+    }, subscribeOnce: (r3, s) => {
+      let n = t ? `${t}/${r3}` : r3;
+      return __privateMethod(this, _T_instances, u_fn2).call(this, n, void 0, s, true), e;
+    }, unsubscribe: (r3, s) => {
+      let n = t ? `${t}/${r3}` : r3;
+      return __privateMethod(this, _T_instances, l_fn2).call(this, n, s), e;
+    } }) };
+    return __privateSet(this, _E, e), e;
+  }
+}, _e7 = new WeakMap(), _t7 = new WeakMap(), _i3 = new WeakMap(), _a9 = new WeakMap(), _s3 = new WeakMap(), _n6 = new WeakMap(), _r3 = new WeakMap(), _h2 = new WeakMap(), _c = new WeakMap(), _E = new WeakMap(), _o2 = new WeakMap(), _T_instances = new WeakSet(), p_fn3 = function(e) {
+  if (e && typeof e == "function") {
+    let t = e._name, r3 = e(this.inject), s = Object.entries(r3);
+    for (let [n, o] of s) {
+      let { handler: c, schema: a, namespace: u, once: h, timeoutMs: d } = o, E2 = u ? `${u}/${t}:${n}` : `${t}:${n}`, f = (...m2) => {
+        try {
+          return c(...m2);
+        } catch (S2) {
+          console.error(`Errow with ${E2}:`, S2);
+        }
+      };
+      __privateMethod(this, _T_instances, u_fn2).call(this, E2, a, f, h, d);
+    }
+  }
+}, u_fn2 = function(e, t, r3, s = false, n = void 0) {
+  __privateGet(this, _s3).has(e) || __privateGet(this, _s3).set(e, /* @__PURE__ */ new Set());
+  let o = { event: e, schema: t, subscriber: r3, once: s, timeoutMs: n };
+  return __privateGet(this, _s3).get(e).add(o), __privateGet(this, _e7) && __privateGet(this, _e7).emit([l.SUBSCRIBE, e, n]), () => __privateGet(this, _s3).get(e)?.delete(o);
+}, l_fn2 = function(e, t) {
+  if (!__privateGet(this, _s3).has(e)) return;
+  let r3 = __privateGet(this, _s3).get(e);
+  for (let s of r3.values()) if (s.subscriber === t) return r3.delete(s), t;
+}, f_fn2 = function(e, t, r3, s = null) {
+  if (!__privateGet(this, _e7)) {
+    console.warn(`[Channel] publish "${t}" dropped \u2014 not connected`);
+    return;
+  }
+  __privateGet(this, _e7).emit([e, t, r3, s]);
+}, d_fn2 = function(e, t, r3, s = null) {
+  return __privateGet(this, _e7) ? __privateGet(this, _e7).request([e, t, r3, s], __privateGet(this, _a9).get(t)) : Promise.reject(new Error(`Channel not connected \u2014 request "${t}" dropped`));
+}, S_fn3 = function(e, t, r3, s = null) {
+  return __privateGet(this, _e7) ? __privateGet(this, _e7).gather([e, t, r3, s], __privateGet(this, _a9).get(t)) : Promise.reject(new Error(`Channel not connected \u2014 gather "${t}" dropped`));
+}, w_fn3 = async function() {
+  try {
+    let e = await __privateGet(this, _e7).request([l.SYNC]);
+    if (Array.isArray(e)) for (let [t, r3] of e) __privateGet(this, _a9).set(t, r3);
+  } catch {
+  }
+}, _m = new WeakMap(), _g = new WeakMap(), _y = new WeakMap(), b_fn2 = function(e) {
+  __privateSet(this, _e7, null), __privateSet(this, _r3, false), __privateGet(this, _a9).clear(), __privateGet(this, _o2).disconnect.forEach((t) => {
+    try {
+      t(e, __privateGet(this, _E));
+    } catch (r3) {
+      console.error("Channel onDisconnect listener error:", r3);
+    }
+  }), e === "peer-lost" && __privateGet(this, _h2) && __privateMethod(this, _T_instances, N_fn).call(this);
+}, N_fn = async function() {
+  if (__privateGet(this, _c)) return;
+  __privateSet(this, _c, true);
+  let e = this.config.reconnectMaxAttempts ?? 5, t = this.config.reconnectBaseDelay ?? 250;
+  try {
+    for (let r3 = 1; r3 <= e; r3++) try {
+      let s = await __privateGet(this, _h2).call(this);
+      if (!w2(s)) throw new Error("portProvider did not return a usable port");
+      if (await __privateGet(this, _E).connect(s) === false) throw new Error("Reconnect handshake failed");
+      console.warn(`[Channel] reconnected after ${r3} attempt(s)`);
+      return;
+    } catch (s) {
+      if (console.warn(`[Channel] reconnect attempt ${r3}/${e} failed:`, s?.message ?? s), r3 < e) {
+        let n = Math.min(t * 2 ** (r3 - 1), 4e3);
+        await new Promise((o) => setTimeout(o, n));
+      }
+    }
+    console.error("[Channel] reconnect failed \u2014 giving up");
+  } finally {
+    __privateSet(this, _c, false);
+  }
+}, C_fn2 = function(e, t, r3) {
+  if (r3 === void 0 || r3 === "*" || r3 === null || t === void 0) return true;
+  if (Array.isArray(r3)) {
+    if (r3.length === 1 && r3[0] === "*") return true;
+    let s = r3.length, n = t.length;
+    if (s !== n) return console.warn(`
+Event:`, e, `
+Expected:`, r3, `
+Received:`, t.map((o) => typeof o)), false;
+    for (let o = 0; o < s; o++) {
+      let c = r3[o], a = t[o], u;
+      if (Array.isArray(a) ? u = "Array" : a === null ? u = "null" : u = Object.prototype.toString.call(a).slice(8, -1), c === "Object" && u === "Array") return console.warn(`
+Event:`, e, `
+Value:`, a), false;
+      if (c !== u) return console.warn(`
+Event:`, e, `
+Value:`, a), false;
+    }
+  }
+  return true;
+}, __publicField(_a10, "manifest", { name: "Channel", dependencies: [], version: "1.0.0", namespace: "channel", description: "Channel extension for message passing between systems", defaults: { port: null, subscriptions: [], timeout: 1e3, reconnectMaxAttempts: 5, reconnectBaseDelay: 250 } }), _a10);
+
+export {
+  g,
+  G,
+  v,
+  nanoid,
+  L2 as L,
+  T2 as T
+};