@moq/watch 0.2.6 → 0.2.7

package/broadcast-BMWX8K5V.js

@@ -0,0 +1,4481 @@
+import * as M from "@moq/lite";
+import { Time as m, Path as $t } from "@moq/lite";
+import { Signal as h, Effect as T } from "@moq/signals";
+function w(t, e, n) {
+  function s(a, c) {
+    if (a._zod || Object.defineProperty(a, "_zod", {
+      value: {
+        def: c,
+        constr: o,
+        traits: /* @__PURE__ */ new Set()
+      },
+      enumerable: !1
+    }), a._zod.traits.has(t))
+      return;
+    a._zod.traits.add(t), e(a, c);
+    const u = o.prototype, l = Object.keys(u);
+    for (let d = 0; d < l.length; d++) {
+      const f = l[d];
+      f in a || (a[f] = u[f].bind(a));
+    }
+  }
+  const i = n?.Parent ?? Object;
+  class r extends i {
+  }
+  Object.defineProperty(r, "name", { value: t });
+  function o(a) {
+    var c;
+    const u = n?.Parent ? new r() : this;
+    s(u, a), (c = u._zod).deferred ?? (c.deferred = []);
+    for (const l of u._zod.deferred)
+      l();
+    return u;
+  }
+  return Object.defineProperty(o, "init", { value: s }), Object.defineProperty(o, Symbol.hasInstance, {
+    value: (a) => n?.Parent && a instanceof n.Parent ? !0 : a?._zod?.traits?.has(t)
+  }), Object.defineProperty(o, "name", { value: t }), o;
+}
+class K extends Error {
+  constructor() {
+    super("Encountered Promise during synchronous parse. Use .parseAsync() instead.");
+  }
+}
+class Ft extends Error {
+  constructor(e) {
+    super(`Encountered unidirectional transform during encode: ${e}`), this.name = "ZodEncodeError";
+  }
+}
+const jt = {};
+function Q(t) {
+  return jt;
+}
+function Zt(t, e) {
+  return typeof e == "bigint" ? e.toString() : e;
+}
+function Ke(t) {
+  return {
+    get value() {
+      {
+        const e = t();
+        return Object.defineProperty(this, "value", { value: e }), e;
+      }
+    }
+  };
+}
+function Je(t) {
+  const e = t.startsWith("^") ? 1 : 0, n = t.endsWith("$") ? t.length - 1 : t.length;
+  return t.slice(e, n);
+}
+const Re = /* @__PURE__ */ Symbol("evaluating");
+function U(t, e, n) {
+  let s;
+  Object.defineProperty(t, e, {
+    get() {
+      if (s !== Re)
+        return s === void 0 && (s = Re, s = n()), s;
+    },
+    set(i) {
+      Object.defineProperty(t, e, {
+        value: i
+        // configurable: true,
+      });
+    },
+    configurable: !0
+  });
+}
+const Qe = "captureStackTrace" in Error ? Error.captureStackTrace : (...t) => {
+};
+function pe(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function et(t) {
+  if (pe(t) === !1)
+    return !1;
+  const e = t.constructor;
+  if (e === void 0 || typeof e != "function")
+    return !0;
+  const n = e.prototype;
+  return !(pe(n) === !1 || Object.prototype.hasOwnProperty.call(n, "isPrototypeOf") === !1);
+}
+function Vt(t) {
+  return et(t) ? { ...t } : Array.isArray(t) ? [...t] : t;
+}
+function Be(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function Wt(t, e, n) {
+  const s = new t._zod.constr(e ?? t._zod.def);
+  return (!e || n?.parent) && (s._zod.parent = t), s;
+}
+function I(t) {
+  return {};
+}
+function qt(t) {
+  return Object.keys(t).filter((e) => t[e]._zod.optin === "optional" && t[e]._zod.optout === "optional");
+}
+const Ht = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-34028234663852886e22, 34028234663852886e22],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+function re(t, e = 0) {
+  if (t.aborted === !0)
+    return !0;
+  for (let n = e; n < t.issues.length; n++)
+    if (t.issues[n]?.continue !== !0)
+      return !0;
+  return !1;
+}
+function X(t, e) {
+  return e.map((n) => {
+    var s;
+    return (s = n).path ?? (s.path = []), n.path.unshift(t), n;
+  });
+}
+function fe(t) {
+  return typeof t == "string" ? t : t?.message;
+}
+function ee(t, e, n) {
+  const s = { ...t, path: t.path ?? [] };
+  if (!t.message) {
+    const i = fe(t.inst?._zod.def?.error?.(t)) ?? fe(e?.error?.(t)) ?? fe(n.customError?.(t)) ?? fe(n.localeError?.(t)) ?? "Invalid input";
+    s.message = i;
+  }
+  return delete s.inst, delete s.continue, e?.reportInput || delete s.input, s;
+}
+const tt = (t, e) => {
+  t.name = "$ZodError", Object.defineProperty(t, "_zod", {
+    value: t._zod,
+    enumerable: !1
+  }), Object.defineProperty(t, "issues", {
+    value: e,
+    enumerable: !1
+  }), t.message = JSON.stringify(e, Zt, 2), Object.defineProperty(t, "toString", {
+    value: () => t.message,
+    enumerable: !1
+  });
+}, Gt = w("$ZodError", tt), ye = w("$ZodError", tt, { Parent: Error }), Xt = (t) => (e, n, s, i) => {
+  const r = s ? Object.assign(s, { async: !1 }) : { async: !1 }, o = e._zod.run({ value: n, issues: [] }, r);
+  if (o instanceof Promise)
+    throw new K();
+  if (o.issues.length) {
+    const a = new (i?.Err ?? t)(o.issues.map((c) => ee(c, r, Q())));
+    throw Qe(a, i?.callee), a;
+  }
+  return o.value;
+}, Yt = /* @__PURE__ */ Xt(ye), Kt = (t) => async (e, n, s, i) => {
+  const r = s ? Object.assign(s, { async: !0 }) : { async: !0 };
+  let o = e._zod.run({ value: n, issues: [] }, r);
+  if (o instanceof Promise && (o = await o), o.issues.length) {
+    const a = new (i?.Err ?? t)(o.issues.map((c) => ee(c, r, Q())));
+    throw Qe(a, i?.callee), a;
+  }
+  return o.value;
+}, Jt = /* @__PURE__ */ Kt(ye), Qt = (t) => (e, n, s) => {
+  const i = s ? { ...s, async: !1 } : { async: !1 }, r = e._zod.run({ value: n, issues: [] }, i);
+  if (r instanceof Promise)
+    throw new K();
+  return r.issues.length ? {
+    success: !1,
+    error: new (t ?? Gt)(r.issues.map((o) => ee(o, i, Q())))
+  } : { success: !0, data: r.value };
+}, nt = /* @__PURE__ */ Qt(ye), en = (t) => async (e, n, s) => {
+  const i = s ? Object.assign(s, { async: !0 }) : { async: !0 };
+  let r = e._zod.run({ value: n, issues: [] }, i);
+  return r instanceof Promise && (r = await r), r.issues.length ? {
+    success: !1,
+    error: new t(r.issues.map((o) => ee(o, i, Q())))
+  } : { success: !0, data: r.value };
+}, st = /* @__PURE__ */ en(ye), tn = (t) => {
+  const e = t ? `[\\s\\S]{${t?.minimum ?? 0},${t?.maximum ?? ""}}` : "[\\s\\S]*";
+  return new RegExp(`^${e}$`);
+}, nn = /^-?\d+$/, it = /^-?\d+(?:\.\d+)?$/, sn = /^(?:true|false)$/i, ze = /* @__PURE__ */ w("$ZodCheck", (t, e) => {
+  var n;
+  t._zod ?? (t._zod = {}), t._zod.def = e, (n = t._zod).onattach ?? (n.onattach = []);
+}), rt = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+}, rn = /* @__PURE__ */ w("$ZodCheckLessThan", (t, e) => {
+  ze.init(t, e);
+  const n = rt[typeof e.value];
+  t._zod.onattach.push((s) => {
+    const i = s._zod.bag, r = (e.inclusive ? i.maximum : i.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+    e.value < r && (e.inclusive ? i.maximum = e.value : i.exclusiveMaximum = e.value);
+  }), t._zod.check = (s) => {
+    (e.inclusive ? s.value <= e.value : s.value < e.value) || s.issues.push({
+      origin: n,
+      code: "too_big",
+      maximum: typeof e.value == "object" ? e.value.getTime() : e.value,
+      input: s.value,
+      inclusive: e.inclusive,
+      inst: t,
+      continue: !e.abort
+    });
+  };
+}), on = /* @__PURE__ */ w("$ZodCheckGreaterThan", (t, e) => {
+  ze.init(t, e);
+  const n = rt[typeof e.value];
+  t._zod.onattach.push((s) => {
+    const i = s._zod.bag, r = (e.inclusive ? i.minimum : i.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+    e.value > r && (e.inclusive ? i.minimum = e.value : i.exclusiveMinimum = e.value);
+  }), t._zod.check = (s) => {
+    (e.inclusive ? s.value >= e.value : s.value > e.value) || s.issues.push({
+      origin: n,
+      code: "too_small",
+      minimum: typeof e.value == "object" ? e.value.getTime() : e.value,
+      input: s.value,
+      inclusive: e.inclusive,
+      inst: t,
+      continue: !e.abort
+    });
+  };
+}), an = /* @__PURE__ */ w("$ZodCheckNumberFormat", (t, e) => {
+  ze.init(t, e), e.format = e.format || "float64";
+  const n = e.format?.includes("int"), s = n ? "int" : "number", [i, r] = Ht[e.format];
+  t._zod.onattach.push((o) => {
+    const a = o._zod.bag;
+    a.format = e.format, a.minimum = i, a.maximum = r, n && (a.pattern = nn);
+  }), t._zod.check = (o) => {
+    const a = o.value;
+    if (n) {
+      if (!Number.isInteger(a)) {
+        o.issues.push({
+          expected: s,
+          format: e.format,
+          code: "invalid_type",
+          continue: !1,
+          input: a,
+          inst: t
+        });
+        return;
+      }
+      if (!Number.isSafeInteger(a)) {
+        a > 0 ? o.issues.push({
+          input: a,
+          code: "too_big",
+          maximum: Number.MAX_SAFE_INTEGER,
+          note: "Integers must be within the safe integer range.",
+          inst: t,
+          origin: s,
+          inclusive: !0,
+          continue: !e.abort
+        }) : o.issues.push({
+          input: a,
+          code: "too_small",
+          minimum: Number.MIN_SAFE_INTEGER,
+          note: "Integers must be within the safe integer range.",
+          inst: t,
+          origin: s,
+          inclusive: !0,
+          continue: !e.abort
+        });
+        return;
+      }
+    }
+    a < i && o.issues.push({
+      origin: "number",
+      input: a,
+      code: "too_small",
+      minimum: i,
+      inclusive: !0,
+      inst: t,
+      continue: !e.abort
+    }), a > r && o.issues.push({
+      origin: "number",
+      input: a,
+      code: "too_big",
+      maximum: r,
+      inclusive: !0,
+      inst: t,
+      continue: !e.abort
+    });
+  };
+}), cn = {
+  major: 4,
+  minor: 3,
+  patch: 6
+}, B = /* @__PURE__ */ w("$ZodType", (t, e) => {
+  var n;
+  t ?? (t = {}), t._zod.def = e, t._zod.bag = t._zod.bag || {}, t._zod.version = cn;
+  const s = [...t._zod.def.checks ?? []];
+  t._zod.traits.has("$ZodCheck") && s.unshift(t);
+  for (const i of s)
+    for (const r of i._zod.onattach)
+      r(t);
+  if (s.length === 0)
+    (n = t._zod).deferred ?? (n.deferred = []), t._zod.deferred?.push(() => {
+      t._zod.run = t._zod.parse;
+    });
+  else {
+    const i = (o, a, c) => {
+      let u = re(o), l;
+      for (const d of a) {
+        if (d._zod.def.when) {
+          if (!d._zod.def.when(o))
+            continue;
+        } else if (u)
+          continue;
+        const f = o.issues.length, g = d._zod.check(o);
+        if (g instanceof Promise && c?.async === !1)
+          throw new K();
+        if (l || g instanceof Promise)
+          l = (l ?? Promise.resolve()).then(async () => {
+            await g, o.issues.length !== f && (u || (u = re(o, f)));
+          });
+        else {
+          if (o.issues.length === f)
+            continue;
+          u || (u = re(o, f));
+        }
+      }
+      return l ? l.then(() => o) : o;
+    }, r = (o, a, c) => {
+      if (re(o))
+        return o.aborted = !0, o;
+      const u = i(a, s, c);
+      if (u instanceof Promise) {
+        if (c.async === !1)
+          throw new K();
+        return u.then((l) => t._zod.parse(l, c));
+      }
+      return t._zod.parse(u, c);
+    };
+    t._zod.run = (o, a) => {
+      if (a.skipChecks)
+        return t._zod.parse(o, a);
+      if (a.direction === "backward") {
+        const u = t._zod.parse({ value: o.value, issues: [] }, { ...a, skipChecks: !0 });
+        return u instanceof Promise ? u.then((l) => r(l, o, a)) : r(u, o, a);
+      }
+      const c = t._zod.parse(o, a);
+      if (c instanceof Promise) {
+        if (a.async === !1)
+          throw new K();
+        return c.then((u) => i(u, s, a));
+      }
+      return i(c, s, a);
+    };
+  }
+  U(t, "~standard", () => ({
+    validate: (i) => {
+      try {
+        const r = nt(t, i);
+        return r.success ? { value: r.data } : { issues: r.error?.issues };
+      } catch {
+        return st(t, i).then((o) => o.success ? { value: o.data } : { issues: o.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  }));
+}), un = /* @__PURE__ */ w("$ZodString", (t, e) => {
+  B.init(t, e), t._zod.pattern = [...t?._zod.bag?.patterns ?? []].pop() ?? tn(t._zod.bag), t._zod.parse = (n, s) => {
+    if (e.coerce)
+      try {
+        n.value = String(n.value);
+      } catch {
+      }
+    return typeof n.value == "string" || n.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: n.value,
+      inst: t
+    }), n;
+  };
+}), ot = /* @__PURE__ */ w("$ZodNumber", (t, e) => {
+  B.init(t, e), t._zod.pattern = t._zod.bag.pattern ?? it, t._zod.parse = (n, s) => {
+    if (e.coerce)
+      try {
+        n.value = Number(n.value);
+      } catch {
+      }
+    const i = n.value;
+    if (typeof i == "number" && !Number.isNaN(i) && Number.isFinite(i))
+      return n;
+    const r = typeof i == "number" ? Number.isNaN(i) ? "NaN" : Number.isFinite(i) ? void 0 : "Infinity" : void 0;
+    return n.issues.push({
+      expected: "number",
+      code: "invalid_type",
+      input: i,
+      inst: t,
+      ...r ? { received: r } : {}
+    }), n;
+  };
+}), ln = /* @__PURE__ */ w("$ZodNumberFormat", (t, e) => {
+  an.init(t, e), ot.init(t, e);
+}), dn = /* @__PURE__ */ w("$ZodBoolean", (t, e) => {
+  B.init(t, e), t._zod.pattern = sn, t._zod.parse = (n, s) => {
+    if (e.coerce)
+      try {
+        n.value = !!n.value;
+      } catch {
+      }
+    const i = n.value;
+    return typeof i == "boolean" || n.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input: i,
+      inst: t
+    }), n;
+  };
+});
+function xe(t, e, n) {
+  t.issues.length && e.issues.push(...X(n, t.issues)), e.value[n] = t.value;
+}
+const hn = /* @__PURE__ */ w("$ZodArray", (t, e) => {
+  B.init(t, e), t._zod.parse = (n, s) => {
+    const i = n.value;
+    if (!Array.isArray(i))
+      return n.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input: i,
+        inst: t
+      }), n;
+    n.value = Array(i.length);
+    const r = [];
+    for (let o = 0; o < i.length; o++) {
+      const a = i[o], c = e.element._zod.run({
+        value: a,
+        issues: []
+      }, s);
+      c instanceof Promise ? r.push(c.then((u) => xe(u, n, o))) : xe(c, n, o);
+    }
+    return r.length ? Promise.all(r).then(() => n) : n;
+  };
+});
+function ge(t, e, n, s, i) {
+  if (t.issues.length) {
+    if (i && !(n in s))
+      return;
+    e.issues.push(...X(n, t.issues));
+  }
+  t.value === void 0 ? n in s && (e.value[n] = void 0) : e.value[n] = t.value;
+}
+function fn(t) {
+  const e = Object.keys(t.shape);
+  for (const s of e)
+    if (!t.shape?.[s]?._zod?.traits?.has("$ZodType"))
+      throw new Error(`Invalid element at key "${s}": expected a Zod schema`);
+  const n = qt(t.shape);
+  return {
+    ...t,
+    keys: e,
+    keySet: new Set(e),
+    numKeys: e.length,
+    optionalKeys: new Set(n)
+  };
+}
+function mn(t, e, n, s, i, r) {
+  const o = [], a = i.keySet, c = i.catchall._zod, u = c.def.type, l = c.optout === "optional";
+  for (const d in e) {
+    if (a.has(d))
+      continue;
+    if (u === "never") {
+      o.push(d);
+      continue;
+    }
+    const f = c.run({ value: e[d], issues: [] }, s);
+    f instanceof Promise ? t.push(f.then((g) => ge(g, n, d, e, l))) : ge(f, n, d, e, l);
+  }
+  return o.length && n.issues.push({
+    code: "unrecognized_keys",
+    keys: o,
+    input: e,
+    inst: r
+  }), t.length ? Promise.all(t).then(() => n) : n;
+}
+const pn = /* @__PURE__ */ w("$ZodObject", (t, e) => {
+  if (B.init(t, e), !Object.getOwnPropertyDescriptor(e, "shape")?.get) {
+    const a = e.shape;
+    Object.defineProperty(e, "shape", {
+      get: () => {
+        const c = { ...a };
+        return Object.defineProperty(e, "shape", {
+          value: c
+        }), c;
+      }
+    });
+  }
+  const s = Ke(() => fn(e));
+  U(t._zod, "propValues", () => {
+    const a = e.shape, c = {};
+    for (const u in a) {
+      const l = a[u]._zod;
+      if (l.values) {
+        c[u] ?? (c[u] = /* @__PURE__ */ new Set());
+        for (const d of l.values)
+          c[u].add(d);
+      }
+    }
+    return c;
+  });
+  const i = pe, r = e.catchall;
+  let o;
+  t._zod.parse = (a, c) => {
+    o ?? (o = s.value);
+    const u = a.value;
+    if (!i(u))
+      return a.issues.push({
+        expected: "object",
+        code: "invalid_type",
+        input: u,
+        inst: t
+      }), a;
+    a.value = {};
+    const l = [], d = o.shape;
+    for (const f of o.keys) {
+      const g = d[f], y = g._zod.optout === "optional", b = g._zod.run({ value: u[f], issues: [] }, c);
+      b instanceof Promise ? l.push(b.then((S) => ge(S, a, f, u, y))) : ge(b, a, f, u, y);
+    }
+    return r ? mn(l, u, a, c, s.value, t) : l.length ? Promise.all(l).then(() => a) : a;
+  };
+});
+function Ie(t, e, n, s) {
+  for (const r of t)
+    if (r.issues.length === 0)
+      return e.value = r.value, e;
+  const i = t.filter((r) => !re(r));
+  return i.length === 1 ? (e.value = i[0].value, i[0]) : (e.issues.push({
+    code: "invalid_union",
+    input: e.value,
+    inst: n,
+    errors: t.map((r) => r.issues.map((o) => ee(o, s, Q())))
+  }), e);
+}
+const at = /* @__PURE__ */ w("$ZodUnion", (t, e) => {
+  B.init(t, e), U(t._zod, "optin", () => e.options.some((i) => i._zod.optin === "optional") ? "optional" : void 0), U(t._zod, "optout", () => e.options.some((i) => i._zod.optout === "optional") ? "optional" : void 0), U(t._zod, "values", () => {
+    if (e.options.every((i) => i._zod.values))
+      return new Set(e.options.flatMap((i) => Array.from(i._zod.values)));
+  }), U(t._zod, "pattern", () => {
+    if (e.options.every((i) => i._zod.pattern)) {
+      const i = e.options.map((r) => r._zod.pattern);
+      return new RegExp(`^(${i.map((r) => Je(r.source)).join("|")})$`);
+    }
+  });
+  const n = e.options.length === 1, s = e.options[0]._zod.run;
+  t._zod.parse = (i, r) => {
+    if (n)
+      return s(i, r);
+    let o = !1;
+    const a = [];
+    for (const c of e.options) {
+      const u = c._zod.run({
+        value: i.value,
+        issues: []
+      }, r);
+      if (u instanceof Promise)
+        a.push(u), o = !0;
+      else {
+        if (u.issues.length === 0)
+          return u;
+        a.push(u);
+      }
+    }
+    return o ? Promise.all(a).then((c) => Ie(c, i, t, r)) : Ie(a, i, t, r);
+  };
+}), gn = /* @__PURE__ */ w("$ZodDiscriminatedUnion", (t, e) => {
+  e.inclusive = !1, at.init(t, e);
+  const n = t._zod.parse;
+  U(t._zod, "propValues", () => {
+    const i = {};
+    for (const r of e.options) {
+      const o = r._zod.propValues;
+      if (!o || Object.keys(o).length === 0)
+        throw new Error(`Invalid discriminated union option at index "${e.options.indexOf(r)}"`);
+      for (const [a, c] of Object.entries(o)) {
+        i[a] || (i[a] = /* @__PURE__ */ new Set());
+        for (const u of c)
+          i[a].add(u);
+      }
+    }
+    return i;
+  });
+  const s = Ke(() => {
+    const i = e.options, r = /* @__PURE__ */ new Map();
+    for (const o of i) {
+      const a = o._zod.propValues?.[e.discriminator];
+      if (!a || a.size === 0)
+        throw new Error(`Invalid discriminated union option at index "${e.options.indexOf(o)}"`);
+      for (const c of a) {
+        if (r.has(c))
+          throw new Error(`Duplicate discriminator value "${String(c)}"`);
+        r.set(c, o);
+      }
+    }
+    return r;
+  });
+  t._zod.parse = (i, r) => {
+    const o = i.value;
+    if (!pe(o))
+      return i.issues.push({
+        code: "invalid_type",
+        expected: "object",
+        input: o,
+        inst: t
+      }), i;
+    const a = s.value.get(o?.[e.discriminator]);
+    return a ? a._zod.run(i, r) : e.unionFallback ? n(i, r) : (i.issues.push({
+      code: "invalid_union",
+      errors: [],
+      note: "No matching discriminator",
+      discriminator: e.discriminator,
+      input: o,
+      path: [e.discriminator],
+      inst: t
+    }), i);
+  };
+}), wn = /* @__PURE__ */ w("$ZodRecord", (t, e) => {
+  B.init(t, e), t._zod.parse = (n, s) => {
+    const i = n.value;
+    if (!et(i))
+      return n.issues.push({
+        expected: "record",
+        code: "invalid_type",
+        input: i,
+        inst: t
+      }), n;
+    const r = [], o = e.keyType._zod.values;
+    if (o) {
+      n.value = {};
+      const a = /* @__PURE__ */ new Set();
+      for (const u of o)
+        if (typeof u == "string" || typeof u == "number" || typeof u == "symbol") {
+          a.add(typeof u == "number" ? u.toString() : u);
+          const l = e.valueType._zod.run({ value: i[u], issues: [] }, s);
+          l instanceof Promise ? r.push(l.then((d) => {
+            d.issues.length && n.issues.push(...X(u, d.issues)), n.value[u] = d.value;
+          })) : (l.issues.length && n.issues.push(...X(u, l.issues)), n.value[u] = l.value);
+        }
+      let c;
+      for (const u in i)
+        a.has(u) || (c = c ?? [], c.push(u));
+      c && c.length > 0 && n.issues.push({
+        code: "unrecognized_keys",
+        input: i,
+        inst: t,
+        keys: c
+      });
+    } else {
+      n.value = {};
+      for (const a of Reflect.ownKeys(i)) {
+        if (a === "__proto__")
+          continue;
+        let c = e.keyType._zod.run({ value: a, issues: [] }, s);
+        if (c instanceof Promise)
+          throw new Error("Async schemas not supported in object keys currently");
+        if (typeof a == "string" && it.test(a) && c.issues.length) {
+          const d = e.keyType._zod.run({ value: Number(a), issues: [] }, s);
+          if (d instanceof Promise)
+            throw new Error("Async schemas not supported in object keys currently");
+          d.issues.length === 0 && (c = d);
+        }
+        if (c.issues.length) {
+          e.mode === "loose" ? n.value[a] = i[a] : n.issues.push({
+            code: "invalid_key",
+            origin: "record",
+            issues: c.issues.map((d) => ee(d, s, Q())),
+            input: a,
+            path: [a],
+            inst: t
+          });
+          continue;
+        }
+        const l = e.valueType._zod.run({ value: i[a], issues: [] }, s);
+        l instanceof Promise ? r.push(l.then((d) => {
+          d.issues.length && n.issues.push(...X(a, d.issues)), n.value[c.value] = d.value;
+        })) : (l.issues.length && n.issues.push(...X(a, l.issues)), n.value[c.value] = l.value);
+      }
+    }
+    return r.length ? Promise.all(r).then(() => n) : n;
+  };
+}), yn = /* @__PURE__ */ w("$ZodLiteral", (t, e) => {
+  if (B.init(t, e), e.values.length === 0)
+    throw new Error("Cannot create literal schema with no valid values");
+  const n = new Set(e.values);
+  t._zod.values = n, t._zod.pattern = new RegExp(`^(${e.values.map((s) => typeof s == "string" ? Be(s) : s ? Be(s.toString()) : String(s)).join("|")})$`), t._zod.parse = (s, i) => {
+    const r = s.value;
+    return n.has(r) || s.issues.push({
+      code: "invalid_value",
+      values: e.values,
+      input: r,
+      inst: t
+    }), s;
+  };
+}), bn = /* @__PURE__ */ w("$ZodTransform", (t, e) => {
+  B.init(t, e), t._zod.parse = (n, s) => {
+    if (s.direction === "backward")
+      throw new Ft(t.constructor.name);
+    const i = e.transform(n.value, n);
+    if (s.async)
+      return (i instanceof Promise ? i : Promise.resolve(i)).then((o) => (n.value = o, n));
+    if (i instanceof Promise)
+      throw new K();
+    return n.value = i, n;
+  };
+});
+function Ce(t, e) {
+  return t.issues.length && e === void 0 ? { issues: [], value: void 0 } : t;
+}
+const vn = /* @__PURE__ */ w("$ZodOptional", (t, e) => {
+  B.init(t, e), t._zod.optin = "optional", t._zod.optout = "optional", U(t._zod, "values", () => e.innerType._zod.values ? /* @__PURE__ */ new Set([...e.innerType._zod.values, void 0]) : void 0), U(t._zod, "pattern", () => {
+    const n = e.innerType._zod.pattern;
+    return n ? new RegExp(`^(${Je(n.source)})?$`) : void 0;
+  }), t._zod.parse = (n, s) => {
+    if (e.innerType._zod.optin === "optional") {
+      const i = e.innerType._zod.run(n, s);
+      return i instanceof Promise ? i.then((r) => Ce(r, n.value)) : Ce(i, n.value);
+    }
+    return n.value === void 0 ? n : e.innerType._zod.run(n, s);
+  };
+}), Sn = /* @__PURE__ */ w("$ZodDefault", (t, e) => {
+  B.init(t, e), t._zod.optin = "optional", U(t._zod, "values", () => e.innerType._zod.values), t._zod.parse = (n, s) => {
+    if (s.direction === "backward")
+      return e.innerType._zod.run(n, s);
+    if (n.value === void 0)
+      return n.value = e.defaultValue, n;
+    const i = e.innerType._zod.run(n, s);
+    return i instanceof Promise ? i.then((r) => Le(r, e)) : Le(i, e);
+  };
+});
+function Le(t, e) {
+  return t.value === void 0 && (t.value = e.defaultValue), t;
+}
+const Mn = /* @__PURE__ */ w("$ZodPipe", (t, e) => {
+  B.init(t, e), U(t._zod, "values", () => e.in._zod.values), U(t._zod, "optin", () => e.in._zod.optin), U(t._zod, "optout", () => e.out._zod.optout), U(t._zod, "propValues", () => e.in._zod.propValues), t._zod.parse = (n, s) => {
+    if (s.direction === "backward") {
+      const r = e.out._zod.run(n, s);
+      return r instanceof Promise ? r.then((o) => me(o, e.in, s)) : me(r, e.in, s);
+    }
+    const i = e.in._zod.run(n, s);
+    return i instanceof Promise ? i.then((r) => me(r, e.out, s)) : me(i, e.out, s);
+  };
+});
+function me(t, e, n) {
+  return t.issues.length ? (t.aborted = !0, t) : e._zod.run({ value: t.value, issues: t.issues }, n);
+}
+var Oe;
+class _n {
+  constructor() {
+    this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map();
+  }
+  add(e, ...n) {
+    const s = n[0];
+    return this._map.set(e, s), s && typeof s == "object" && "id" in s && this._idmap.set(s.id, e), this;
+  }
+  clear() {
+    return this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map(), this;
+  }
+  remove(e) {
+    const n = this._map.get(e);
+    return n && typeof n == "object" && "id" in n && this._idmap.delete(n.id), this._map.delete(e), this;
+  }
+  get(e) {
+    const n = e._zod.parent;
+    if (n) {
+      const s = { ...this.get(n) ?? {} };
+      delete s.id;
+      const i = { ...s, ...this._map.get(e) };
+      return Object.keys(i).length ? i : void 0;
+    }
+    return this._map.get(e);
+  }
+  has(e) {
+    return this._map.has(e);
+  }
+}
+function zn() {
+  return new _n();
+}
+(Oe = globalThis).__zod_globalRegistry ?? (Oe.__zod_globalRegistry = zn());
+// @__NO_SIDE_EFFECTS__
+function An(t, e) {
+  return new t({
+    type: "string",
+    ...I()
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function kn(t, e) {
+  return new t({
+    type: "number",
+    checks: [],
+    ...I()
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Tn(t, e) {
+  return new t({
+    type: "number",
+    check: "number_format",
+    abort: !1,
+    format: "safeint",
+    ...I()
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function En(t, e) {
+  return new t({
+    type: "boolean",
+    ...I()
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function ct(t, e) {
+  return new rn({
+    check: "less_than",
+    ...I(),
+    value: t,
+    inclusive: !0
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function Un(t, e) {
+  return new on({
+    check: "greater_than",
+    ...I(),
+    value: t,
+    inclusive: !0
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function ut(t) {
+  return /* @__PURE__ */ Un(0);
+}
+const x = /* @__PURE__ */ w("ZodMiniType", (t, e) => {
+  if (!t._zod)
+    throw new Error("Uninitialized schema in ZodMiniType.");
+  B.init(t, e), t.def = e, t.type = e.type, t.parse = (n, s) => Yt(t, n, s, { callee: t.parse }), t.safeParse = (n, s) => nt(t, n, s), t.parseAsync = async (n, s) => Jt(t, n, s, { callee: t.parseAsync }), t.safeParseAsync = async (n, s) => st(t, n, s), t.check = (...n) => t.clone({
+    ...e,
+    checks: [
+      ...e.checks ?? [],
+      ...n.map((s) => typeof s == "function" ? { _zod: { check: s, def: { check: "custom" }, onattach: [] } } : s)
+    ]
+  }, { parent: !0 }), t.with = t.check, t.clone = (n, s) => Wt(t, n, s), t.brand = () => t, t.register = ((n, s) => (n.add(t, s), t)), t.apply = (n) => n(t);
+}), Rn = /* @__PURE__ */ w("ZodMiniString", (t, e) => {
+  un.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function v(t) {
+  return /* @__PURE__ */ An(Rn);
+}
+const lt = /* @__PURE__ */ w("ZodMiniNumber", (t, e) => {
+  ot.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function Z(t) {
+  return /* @__PURE__ */ kn(lt);
+}
+const Bn = /* @__PURE__ */ w("ZodMiniNumberFormat", (t, e) => {
+  ln.init(t, e), lt.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function dt(t) {
+  return /* @__PURE__ */ Tn(Bn);
+}
+const xn = /* @__PURE__ */ w("ZodMiniBoolean", (t, e) => {
+  dn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function ht(t) {
+  return /* @__PURE__ */ En(xn);
+}
+const In = /* @__PURE__ */ w("ZodMiniArray", (t, e) => {
+  hn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function q(t, e) {
+  return new In({
+    type: "array",
+    element: t,
+    ...I()
+  });
+}
+const Cn = /* @__PURE__ */ w("ZodMiniObject", (t, e) => {
+  pn.init(t, e), x.init(t, e), U(t, "shape", () => e.shape);
+});
+// @__NO_SIDE_EFFECTS__
+function _(t, e) {
+  const n = {
+    type: "object",
+    shape: t ?? {},
+    ...I()
+  };
+  return new Cn(n);
+}
+const Ln = /* @__PURE__ */ w("ZodMiniUnion", (t, e) => {
+  at.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function ft(t, e) {
+  return new Ln({
+    type: "union",
+    options: t,
+    ...I()
+  });
+}
+const On = /* @__PURE__ */ w("ZodMiniDiscriminatedUnion", (t, e) => {
+  gn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function Dn(t, e, n) {
+  return new On({
+    type: "union",
+    options: e,
+    discriminator: t,
+    ...I()
+  });
+}
+const Pn = /* @__PURE__ */ w("ZodMiniRecord", (t, e) => {
+  wn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function Ae(t, e, n) {
+  return new Pn({
+    type: "record",
+    keyType: t,
+    valueType: e,
+    ...I()
+  });
+}
+const Nn = /* @__PURE__ */ w("ZodMiniLiteral", (t, e) => {
+  yn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function De(t, e) {
+  return new Nn({
+    type: "literal",
+    values: Array.isArray(t) ? t : [t],
+    ...I()
+  });
+}
+const $n = /* @__PURE__ */ w("ZodMiniTransform", (t, e) => {
+  bn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function mt(t) {
+  return new $n({
+    type: "transform",
+    transform: t
+  });
+}
+const Fn = /* @__PURE__ */ w("ZodMiniOptional", (t, e) => {
+  vn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function p(t) {
+  return new Fn({
+    type: "optional",
+    innerType: t
+  });
+}
+const jn = /* @__PURE__ */ w("ZodMiniDefault", (t, e) => {
+  Sn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function Zn(t, e) {
+  return new jn({
+    type: "default",
+    innerType: t,
+    get defaultValue() {
+      return typeof e == "function" ? e() : Vt(e);
+    }
+  });
+}
+const Vn = /* @__PURE__ */ w("ZodMiniPipe", (t, e) => {
+  Mn.init(t, e), x.init(t, e);
+});
+// @__NO_SIDE_EFFECTS__
+function pt(t, e) {
+  return new Vn({
+    type: "pipe",
+    in: t,
+    out: e
+  });
+}
+(/* @__PURE__ */ Z()).check(/* @__PURE__ */ dt(), /* @__PURE__ */ ut(), /* @__PURE__ */ ct(255)).brand("u8");
+const R = (/* @__PURE__ */ Z()).check(/* @__PURE__ */ dt(), /* @__PURE__ */ ut(), /* @__PURE__ */ ct(Number.MAX_SAFE_INTEGER)).brand("u53"), gt = /* @__PURE__ */ Zn(
+  /* @__PURE__ */ Dn("kind", [
+    // The default hang container
+    /* @__PURE__ */ _({ kind: /* @__PURE__ */ De("legacy") }),
+    // CMAF container with timescale for timestamp conversion
+    /* @__PURE__ */ _({
+      kind: /* @__PURE__ */ De("cmaf"),
+      // Time units per second
+      timescale: R,
+      // Track ID used in the moof/mdat fragments
+      trackId: R
+    })
+  ]),
+  { kind: "legacy" }
+), Wn = /* @__PURE__ */ _({
+  name: /* @__PURE__ */ v()
+}), Pe = /* @__PURE__ */ _({
+  // See: https://w3c.github.io/webcodecs/codec_registry.html
+  codec: /* @__PURE__ */ v(),
+  // The container format, used to decode the timestamp and more.
+  container: gt,
+  // The description is used for some codecs.
+  // If provided, we can initialize the decoder based on the catalog alone.
+  // Otherwise, the initialization information is in-band.
+  description: /* @__PURE__ */ p(/* @__PURE__ */ v()),
+  // hex encoded TODO use base64
+  // The sample rate of the audio in Hz
+  sampleRate: R,
+  // The number of channels in the audio
+  numberOfChannels: R,
+  // The bitrate of the audio in bits per second
+  // TODO: Support up to Number.MAX_SAFE_INTEGER
+  bitrate: /* @__PURE__ */ p(R),
+  // The maximum jitter before the next frame is emitted in milliseconds.
+  // The player's jitter buffer should be larger than this value.
+  // If not provided, the player should assume each frame is flushed immediately.
+  //
+  // NOTE: The audio "frame" duration depends on the codec, sample rate, etc.
+  // ex: AAC often uses 1024 samples per frame, so at 44100Hz, this would be 1024/44100 = 23ms
+  jitter: /* @__PURE__ */ p(R)
+}), qn = /* @__PURE__ */ ft([
+  /* @__PURE__ */ _({
+    // A map of track name to rendition configuration.
+    // This is not an array so it will work with JSON Merge Patch.
+    renditions: /* @__PURE__ */ Ae(/* @__PURE__ */ v(), Pe)
+  }),
+  // Backwards compatibility: transform old {track, config} format to new object format
+  /* @__PURE__ */ pt(
+    /* @__PURE__ */ _({
+      track: Wn,
+      config: Pe
+    }),
+    /* @__PURE__ */ mt((t) => ({
+      renditions: { [t.track.name]: t.config }
+    }))
+  )
+]), Hn = /* @__PURE__ */ _({
+  hardware: /* @__PURE__ */ p(/* @__PURE__ */ q(/* @__PURE__ */ v())),
+  software: /* @__PURE__ */ p(/* @__PURE__ */ q(/* @__PURE__ */ v())),
+  unsupported: /* @__PURE__ */ p(/* @__PURE__ */ q(/* @__PURE__ */ v()))
+}), Gn = /* @__PURE__ */ _({
+  hardware: /* @__PURE__ */ p(/* @__PURE__ */ q(/* @__PURE__ */ v())),
+  software: /* @__PURE__ */ p(/* @__PURE__ */ q(/* @__PURE__ */ v())),
+  unsupported: /* @__PURE__ */ p(/* @__PURE__ */ q(/* @__PURE__ */ v()))
+}), Xn = /* @__PURE__ */ _({
+  video: /* @__PURE__ */ p(Hn),
+  audio: /* @__PURE__ */ p(Gn)
+}), ue = /* @__PURE__ */ _({
+  name: /* @__PURE__ */ v()
+}), Yn = /* @__PURE__ */ _({
+  message: /* @__PURE__ */ p(ue),
+  typing: /* @__PURE__ */ p(ue)
+}), wt = /* @__PURE__ */ _({
+  // The relative X position of the broadcast, from -1 to +1.
+  // This should be used for audio panning but can also be used for video positioning.
+  x: /* @__PURE__ */ p(/* @__PURE__ */ Z()),
+  // The relative Y position of the broadcast, from -1 to +1.
+  // This can be used for video positioning, and maybe audio panning.
+  y: /* @__PURE__ */ p(/* @__PURE__ */ Z()),
+  // The relative Z index of the broadcast, where larger values are closer to the viewer.
+  // This is used to break ties when there are multiple broadcasts at the same position.
+  z: /* @__PURE__ */ p(/* @__PURE__ */ Z()),
+  // The scale of the broadcast, where 1 is 100%
+  s: /* @__PURE__ */ p(/* @__PURE__ */ Z())
+}), Kn = /* @__PURE__ */ _({
+  // The initial position of the broadcaster, from -1 to +1 in both dimensions.
+  // If not provided, then the broadcaster is assumed to be at (0,0)
+  // This should be used for audio panning but can also be used for video positioning.
+  initial: /* @__PURE__ */ p(wt),
+  // If provided, then updates to the position are done via a separate Moq track.
+  // This is used to avoid a full catalog update every time we want to update a few bytes.
+  // TODO: These updates currently use JSON for simplicity, but we should use a binary format.
+  track: /* @__PURE__ */ p(ue),
+  // If set, then this broadcaster allows other peers to request position updates via this handle.
+  // We will have to discover and subscribe to their position updates.
+  handle: /* @__PURE__ */ p(/* @__PURE__ */ v()),
+  // If provided, this broadcaster is signaling the location of other peers.
+  // The payload is a JSON blob keyed by handle for each peer.
+  peers: /* @__PURE__ */ p(ue)
+}), Ri = /* @__PURE__ */ Ae(/* @__PURE__ */ v(), wt), J = {
+  catalog: 100,
+  chat: 90,
+  audio: 80,
+  video: 60,
+  typing: 40,
+  location: 20,
+  preview: 10
+}, Jn = /* @__PURE__ */ _({
+  id: /* @__PURE__ */ p(/* @__PURE__ */ v()),
+  name: /* @__PURE__ */ p(/* @__PURE__ */ v()),
+  avatar: /* @__PURE__ */ p(/* @__PURE__ */ v()),
+  // TODO allow using a track instead of a URL?
+  color: /* @__PURE__ */ p(/* @__PURE__ */ v())
+}), Qn = /* @__PURE__ */ _({
+  name: /* @__PURE__ */ v()
+}), Ne = /* @__PURE__ */ _({
+  // See: https://w3c.github.io/webcodecs/codec_registry.html
+  codec: /* @__PURE__ */ v(),
+  // The container format, used to decode the timestamp and more.
+  container: gt,
+  // The description is used for some codecs.
+  // If provided, we can initialize the decoder based on the catalog alone.
+  // Otherwise, the initialization information is (repeated) before each key-frame.
+  description: /* @__PURE__ */ p(/* @__PURE__ */ v()),
+  // hex encoded TODO use base64
+  // The width and height of the video in pixels.
+  // NOTE: formats that don't use a description can adjust these values in-band.
+  codedWidth: /* @__PURE__ */ p(R),
+  codedHeight: /* @__PURE__ */ p(R),
+  // Ratio of display width/height to coded width/height
+  // Allows stretching/squishing individual "pixels" of the video
+  // If not provided, the display ratio is 1:1
+  displayAspectWidth: /* @__PURE__ */ p(R),
+  displayAspectHeight: /* @__PURE__ */ p(R),
+  // The frame rate of the video in frames per second
+  framerate: /* @__PURE__ */ p(/* @__PURE__ */ Z()),
+  // The bitrate of the video in bits per second
+  // TODO: Support up to Number.MAX_SAFE_INTEGER
+  bitrate: /* @__PURE__ */ p(R),
+  // If true, the decoder will optimize for latency.
+  // Default: true
+  optimizeForLatency: /* @__PURE__ */ p(/* @__PURE__ */ ht()),
+  // The maximum jitter before the next frame is emitted in milliseconds.
+  // The player's jitter buffer should be larger than this value.
+  // If not provided, the player should assume each frame is flushed immediately.
+  //
+  // ex:
+  // - If each frame is flushed immediately, this would be 1000/fps.
+  // - If there can be up to 3 b-frames in a row, this would be 3 * 1000/fps.
+  // - If frames are buffered into 2s segments, this would be 2s.
+  jitter: /* @__PURE__ */ p(R)
+}), es = /* @__PURE__ */ ft([
+  /* @__PURE__ */ _({
+    // A map of track name to rendition configuration.
+    // This is not an array in order for it to work with JSON Merge Patch.
+    renditions: /* @__PURE__ */ Ae(/* @__PURE__ */ v(), Ne),
+    // Render the video at this size in pixels.
+    // This is separate from the display aspect ratio because it does not require reinitialization.
+    display: /* @__PURE__ */ p(
+      /* @__PURE__ */ _({
+        width: R,
+        height: R
+      })
+    ),
+    // The rotation of the video in degrees.
+    // Default: 0
+    rotation: /* @__PURE__ */ p(/* @__PURE__ */ Z()),
+    // If true, the decoder will flip the video horizontally
+    // Default: false
+    flip: /* @__PURE__ */ p(/* @__PURE__ */ ht())
+  }),
+  // Backwards compatibility: transform old array of {track, config} to new object format
+  /* @__PURE__ */ pt(
+    /* @__PURE__ */ q(
+      /* @__PURE__ */ _({
+        track: Qn,
+        config: Ne
+      })
+    ),
+    /* @__PURE__ */ mt((t) => {
+      const e = t[0]?.config;
+      return {
+        renditions: Object.fromEntries(t.map((n) => [n.track.name, n.config])),
+        display: e?.displayAspectWidth !== void 0 && e?.displayAspectHeight !== void 0 ? { width: e.displayAspectWidth, height: e.displayAspectHeight } : void 0,
+        rotation: void 0,
+        flip: void 0
+      };
+    })
+  )
+]), ts = /* @__PURE__ */ _({
+  video: /* @__PURE__ */ p(es),
+  audio: /* @__PURE__ */ p(qn),
+  location: /* @__PURE__ */ p(Kn),
+  user: /* @__PURE__ */ p(Jn),
+  chat: /* @__PURE__ */ p(Yn),
+  capabilities: /* @__PURE__ */ p(Xn),
+  preview: /* @__PURE__ */ p(ue)
+});
+function ns(t) {
+  const n = new TextDecoder().decode(t);
+  try {
+    const s = JSON.parse(n);
+    return ts.parse(s);
+  } catch (s) {
+    throw console.warn("invalid catalog", n), s;
+  }
+}
+async function ss(t) {
+  const e = await t.readFrame();
+  if (e)
+    return ns(e);
+}
+function yt(t) {
+  return t instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && t instanceof SharedArrayBuffer;
+}
+const is = "utf-16", ve = "utf-16be", $e = "utf-16le", ae = "utf-8";
+function bt(t, e = {}) {
+  let n;
+  yt(t) ? n = new DataView(t) : n = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  let s = 0, { encoding: i } = e;
+  if (!i) {
+    const u = n.getUint8(0), l = n.getUint8(1);
+    u == 239 && l == 187 && n.getUint8(2) == 191 ? (i = ae, s = 3) : u == 254 && l == 255 ? (i = ve, s = 2) : u == 255 && l == 254 ? (i = $e, s = 2) : i = ae;
+  }
+  if (typeof TextDecoder < "u") return new TextDecoder(i).decode(n);
+  const { byteLength: r } = n, o = i !== ve;
+  let a = "", c;
+  for (; s < r; ) {
+    switch (i) {
+      case ae:
+        if (c = n.getUint8(s), c < 128) s++;
+        else if (c >= 194 && c <= 223) if (s + 1 < r) {
+          const u = n.getUint8(s + 1);
+          u >= 128 && u <= 191 ? (c = (c & 31) << 6 | u & 63, s += 2) : s++;
+        } else s++;
+        else if (c >= 224 && c <= 239) if (s + 2 <= r - 1) {
+          const u = n.getUint8(s + 1), l = n.getUint8(s + 2);
+          u >= 128 && u <= 191 && l >= 128 && l <= 191 ? (c = (c & 15) << 12 | (u & 63) << 6 | l & 63, s += 3) : s++;
+        } else s++;
+        else if (c >= 240 && c <= 244) if (s + 3 <= r - 1) {
+          const u = n.getUint8(s + 1), l = n.getUint8(s + 2), d = n.getUint8(s + 3);
+          u >= 128 && u <= 191 && l >= 128 && l <= 191 && d >= 128 && d <= 191 ? (c = (c & 7) << 18 | (u & 63) << 12 | (l & 63) << 6 | d & 63, s += 4) : s++;
+        } else s++;
+        else s++;
+        break;
+      case ve:
+      case is:
+      case $e:
+        c = n.getUint16(s, o), s += 2;
+        break;
+    }
+    a += String.fromCodePoint(c);
+  }
+  return a;
+}
+function rs(t) {
+  return new TextEncoder().encode(t);
+}
+function os(t) {
+  return { writers: t?.writers ?? {} };
+}
+const as = [
+  "dinf",
+  "edts",
+  "grpl",
+  "mdia",
+  "meco",
+  "mfra",
+  "minf",
+  "moof",
+  "moov",
+  "mvex",
+  "schi",
+  "sinf",
+  "stbl",
+  "strk",
+  "traf",
+  "trak",
+  "tref",
+  "udta",
+  "vttc"
+];
+function vt(t) {
+  return "boxes" in t || as.includes(t.type);
+}
+const Fe = "utf8", V = "uint", le = "template", je = "string", Ze = "int", Ve = "data";
+var k = class {
+  /**
+  * Constructs a new IsoBoxWriteView.
+  *
+  * @param size - The size of the data view.
+  */
+  constructor(t, e) {
+    this.writeUint = (n, s) => {
+      const { dataView: i, cursor: r } = this;
+      switch (s) {
+        case 1:
+          i.setUint8(r, n);
+          break;
+        case 2:
+          i.setUint16(r, n);
+          break;
+        case 3: {
+          const o = (n & 16776960) >> 8, a = n & 255;
+          i.setUint16(r, o), i.setUint8(r + 2, a);
+          break;
+        }
+        case 4:
+          i.setUint32(r, n);
+          break;
+        case 8: {
+          const o = Math.floor(n / Math.pow(2, 32)), a = n - o * Math.pow(2, 32);
+          i.setUint32(r, o), i.setUint32(r + 4, a);
+          break;
+        }
+      }
+      this.cursor += s;
+    }, this.writeInt = (n, s) => {
+      const { dataView: i, cursor: r } = this;
+      switch (s) {
+        case 1:
+          i.setInt8(r, n);
+          break;
+        case 2:
+          i.setInt16(r, n);
+          break;
+        case 4:
+          i.setInt32(r, n);
+          break;
+        case 8:
+          const o = Math.floor(n / Math.pow(2, 32)), a = n - o * Math.pow(2, 32);
+          i.setUint32(r, o), i.setUint32(r + 4, a);
+          break;
+      }
+      this.cursor += s;
+    }, this.writeString = (n) => {
+      for (let s = 0, i = n.length; s < i; s++) this.writeUint(n.charCodeAt(s), 1);
+    }, this.writeTerminatedString = (n) => {
+      if (n.length !== 0) {
+        for (let s = 0, i = n.length; s < i; s++) this.writeUint(n.charCodeAt(s), 1);
+        this.writeUint(0, 1);
+      }
+    }, this.writeUtf8TerminatedString = (n) => {
+      const s = rs(n);
+      new Uint8Array(this.dataView.buffer).set(s, this.cursor), this.cursor += s.length, this.writeUint(0, 1);
+    }, this.writeBytes = (n) => {
+      Array.isArray(n) || (n = [n]);
+      for (const s of n)
+        new Uint8Array(this.dataView.buffer).set(s, this.cursor), this.cursor += s.length;
+    }, this.writeArray = (n, s, i, r) => {
+      const o = s === V ? this.writeUint : s === le ? this.writeTemplate : this.writeInt;
+      for (let a = 0; a < r; a++) o(n[a] ?? 0, i);
+    }, this.writeTemplate = (n, s) => {
+      const r = Math.round(n * Math.pow(2, s === 4 ? 16 : 8));
+      this.writeUint(r, s);
+    }, this.writeBoxHeader = (n, s) => {
+      s > 4294967295 ? (this.writeUint(1, 4), this.writeString(n), this.writeUint(s, 8)) : (this.writeUint(s, 4), this.writeString(n));
+    }, this.dataView = new DataView(new ArrayBuffer(e)), this.cursor = 0, this.writeBoxHeader(t, e);
+  }
+  /**
+  * The buffer of the data view.
+  *
+  * @returns The buffer of the data view.
+  */
+  get buffer() {
+    return this.dataView.buffer;
+  }
+  /**
+  * The length of the data view.
+  *
+  * @returns The length of the data view.
+  */
+  get byteLength() {
+    return this.dataView.byteLength;
+  }
+  /**
+  * The offset of the data view.
+  *
+  * @returns The offset of the data view.
+  */
+  get byteOffset() {
+    return this.dataView.byteOffset;
+  }
+  /**
+  * Writes a full box header to the data view.
+  *
+  * @param version - The version of the full box.
+  * @param flags - The flags of the full box.
+  */
+  writeFullBox(t, e) {
+    this.writeUint(t, 1), this.writeUint(e, 3);
+  }
+};
+function St(t, e) {
+  return Array.from(t, (n) => us(n, e));
+}
+function ke(t, e) {
+  const n = St(t, e);
+  return {
+    bytes: n,
+    size: n.reduce((s, i) => s + i.byteLength, 0)
+  };
+}
+function cs(t, e) {
+  const { bytes: s, size: i } = ke(t.boxes, e), r = 8 + i, o = new k(t.type, r);
+  return o.writeBytes(s), o;
+}
+function us(t, e) {
+  let n = null;
+  if ("type" in t) {
+    const { type: s } = t, i = e.writers?.[s];
+    if (i ? n = i(t, e) : vt(t) ? n = cs(t, e) : "view" in t && (n = t.view), !n) throw new Error(`No writer found for box type: ${s}`);
+  }
+  if ("buffer" in t && (n = t), !n) throw new Error("Invalid box");
+  return new Uint8Array(n.buffer, n.byteOffset, n.byteLength);
+}
+function ls(t, e, n) {
+  const s = n > 0 ? n : t.byteLength - (e - t.byteOffset);
+  return new Uint8Array(t.buffer, e, Math.max(s, 0));
+}
+function ds(t, e, n) {
+  let s = NaN;
+  const i = e - t.byteOffset;
+  switch (n) {
+    case 1:
+      s = t.getInt8(i);
+      break;
+    case 2:
+      s = t.getInt16(i);
+      break;
+    case 4:
+      s = t.getInt32(i);
+      break;
+    case 8:
+      const r = t.getInt32(i), o = t.getInt32(i + 4);
+      s = r * Math.pow(2, 32) + o;
+      break;
+  }
+  return s;
+}
+function H(t, e, n) {
+  const s = e - t.byteOffset;
+  let i = NaN, r, o;
+  switch (n) {
+    case 1:
+      i = t.getUint8(s);
+      break;
+    case 2:
+      i = t.getUint16(s);
+      break;
+    case 3:
+      r = t.getUint16(s), o = t.getUint8(s + 2), i = (r << 8) + o;
+      break;
+    case 4:
+      i = t.getUint32(s);
+      break;
+    case 8:
+      r = t.getUint32(s), o = t.getUint32(s + 4), i = r * Math.pow(2, 32) + o;
+      break;
+  }
+  return i;
+}
+function We(t, e, n) {
+  let s = "";
+  for (let i = 0; i < n; i++) {
+    const r = H(t, e + i, 1);
+    s += String.fromCharCode(r);
+  }
+  return s;
+}
+function hs(t, e, n) {
+  const s = n / 2;
+  return H(t, e, s) + H(t, e + s, s) / Math.pow(2, s);
+}
+function fs(t, e) {
+  let n = "", s = e;
+  for (; s - t.byteOffset < t.byteLength; ) {
+    const i = H(t, s, 1);
+    if (i === 0) break;
+    n += String.fromCharCode(i), s++;
+  }
+  return n;
+}
+function ms(t, e) {
+  const n = t.byteLength - (e - t.byteOffset);
+  return n > 0 ? bt(new DataView(t.buffer, e, n), { encoding: ae }) : "";
+}
+function ps(t, e) {
+  const n = t.byteLength - (e - t.byteOffset);
+  let s = "";
+  if (n > 0) {
+    const i = new DataView(t.buffer, e, n);
+    let r = 0;
+    for (; r < n && i.getUint8(r) !== 0; r++) ;
+    s = bt(new DataView(t.buffer, e, r), { encoding: ae });
+  }
+  return s;
+}
+var gs = class Mt {
+  /**
+  * Creates a new IsoView instance. Similar to DataView, but with additional
+  * methods for reading ISO BMFF data. It implements the iterator protocol,
+  * so it can be used in a for...of loop.
+  *
+  * @param raw - The raw data to view.
+  * @param config - The configuration for the IsoView.
+  */
+  constructor(e, n) {
+    this.truncated = !1, this.slice = (s, i) => {
+      const r = new Mt(new DataView(this.dataView.buffer, s, i), this.config), o = this.offset - s, a = i - o;
+      return this.offset += a, r.jump(o), r;
+    }, this.read = (s, i = 0) => {
+      const { dataView: r, offset: o } = this;
+      let a, c = i;
+      switch (s) {
+        case V:
+          a = H(r, o, i);
+          break;
+        case Ze:
+          a = ds(r, o, i);
+          break;
+        case le:
+          a = hs(r, o, i);
+          break;
+        case je:
+          i === -1 ? (a = fs(r, o), c = a.length + 1) : a = We(r, o, i);
+          break;
+        case Ve:
+          a = ls(r, o, i), c = a.length;
+          break;
+        case Fe:
+          i === -1 ? (a = ps(r, o), c = a.length + 1) : a = ms(r, o);
+          break;
+        default:
+          a = -1;
+      }
+      return this.offset += c, a;
+    }, this.readUint = (s) => this.read(V, s), this.readInt = (s) => this.read(Ze, s), this.readString = (s) => this.read(je, s), this.readTemplate = (s) => this.read(le, s), this.readData = (s) => this.read(Ve, s), this.readUtf8 = (s) => this.read(Fe, s), this.readFullBox = () => ({
+      version: this.readUint(1),
+      flags: this.readUint(3)
+    }), this.readArray = (s, i, r) => {
+      const o = [];
+      for (let a = 0; a < r; a++) o.push(this.read(s, i));
+      return o;
+    }, this.jump = (s) => {
+      this.offset += s;
+    }, this.readBox = () => {
+      const { dataView: s, offset: i } = this;
+      let r = 0;
+      const o = H(s, i, 4), a = We(s, i + 4, 4), c = {
+        size: o,
+        type: a
+      };
+      r += 8, c.size === 1 && (c.largesize = H(s, i + r, 8), r += 8);
+      const u = c.size === 0 ? this.bytesRemaining : c.largesize ?? c.size;
+      if (this.cursor + u > s.byteLength)
+        throw this.truncated = !0, new Error("Truncated box");
+      return this.jump(r), a === "uuid" && (c.usertype = this.readArray("uint", 1, 16)), c.view = this.slice(i, u), c;
+    }, this.readBoxes = (s = -1) => {
+      const i = [];
+      for (const r of this)
+        if (i.push(r), s > 0 && i.length >= s) break;
+      return i;
+    }, this.readEntries = (s, i) => {
+      const r = [];
+      for (let o = 0; o < s; o++) r.push(i());
+      return r;
+    }, this.dataView = yt(e) ? new DataView(e) : e instanceof DataView ? e : new DataView(e.buffer, e.byteOffset, e.byteLength), this.offset = this.dataView.byteOffset, this.config = n || {};
+  }
+  /**
+  * The buffer of the data view.
+  */
+  get buffer() {
+    return this.dataView.buffer;
+  }
+  /**
+  * The byte offset of the data view.
+  */
+  get byteOffset() {
+    return this.dataView.byteOffset;
+  }
+  /**
+  * The byte length of the data view.
+  */
+  get byteLength() {
+    return this.dataView.byteLength;
+  }
+  /**
+  * The current byteoffset in the data view.
+  */
+  get cursor() {
+    return this.offset - this.dataView.byteOffset;
+  }
+  /**
+  * Whether the end of the data view has been reached.
+  */
+  get done() {
+    return this.cursor >= this.dataView.byteLength || this.truncated;
+  }
+  /**
+  * The number of bytes remaining in the data view.
+  */
+  get bytesRemaining() {
+    return this.dataView.byteLength - this.cursor;
+  }
+  /**
+  * Iterates over the boxes in the data view.
+  *
+  * @returns A generator of boxes.
+  */
+  *[Symbol.iterator]() {
+    const { readers: e = {} } = this.config;
+    for (; !this.done; ) try {
+      const n = this.readBox(), { type: s, view: i } = n, r = e[s] || e[s.trim()];
+      if (r && Object.assign(n, r(i, s)), vt(n) && !n.boxes) {
+        const o = [];
+        for (const a of i) o.push(a);
+        n.boxes = o;
+      }
+      yield n;
+    } catch (n) {
+      if (n instanceof Error && n.message === "Truncated box") break;
+      throw n;
+    }
+  }
+};
+function _t(t, e) {
+  const n = [];
+  for (const s of new gs(t, e)) n.push(s);
+  return n;
+}
+function ws(t, e) {
+  return St(t, os(e));
+}
+function ys(t) {
+  return {
+    type: "mdat",
+    data: t.readData(-1)
+  };
+}
+function bs(t) {
+  return {
+    type: "mfhd",
+    ...t.readFullBox(),
+    sequenceNumber: t.readUint(4)
+  };
+}
+function vs(t) {
+  const { version: e, flags: n } = t.readFullBox();
+  return {
+    type: "tfdt",
+    version: e,
+    flags: n,
+    baseMediaDecodeTime: t.readUint(e == 1 ? 8 : 4)
+  };
+}
+function Ss(t) {
+  const { version: e, flags: n } = t.readFullBox();
+  return {
+    type: "tfhd",
+    version: e,
+    flags: n,
+    trackId: t.readUint(4),
+    baseDataOffset: n & 1 ? t.readUint(8) : void 0,
+    sampleDescriptionIndex: n & 2 ? t.readUint(4) : void 0,
+    defaultSampleDuration: n & 8 ? t.readUint(4) : void 0,
+    defaultSampleSize: n & 16 ? t.readUint(4) : void 0,
+    defaultSampleFlags: n & 32 ? t.readUint(4) : void 0
+  };
+}
+function Ms(t) {
+  const { version: e, flags: n } = t.readFullBox(), s = t.readUint(4);
+  let i, r;
+  n & 1 && (i = t.readInt(4)), n & 4 && (r = t.readUint(4));
+  const o = t.readEntries(s, () => {
+    const a = {};
+    return n & 256 && (a.sampleDuration = t.readUint(4)), n & 512 && (a.sampleSize = t.readUint(4)), n & 1024 && (a.sampleFlags = t.readUint(4)), n & 2048 && (a.sampleCompositionTimeOffset = e === 1 ? t.readInt(4) : t.readUint(4)), a;
+  });
+  return {
+    type: "trun",
+    version: e,
+    flags: n,
+    sampleCount: s,
+    dataOffset: i,
+    firstSampleFlags: r,
+    samples: o
+  };
+}
+function _s(t, e) {
+  const r = t.entries.length, { bytes: o, size: a } = ke(t.entries, e), c = new k("dref", 16 + a);
+  return c.writeFullBox(t.version, t.flags), c.writeUint(r, 4), c.writeBytes(o), c;
+}
+function zs(t) {
+  const i = t.compatibleBrands.length * 4, r = new k("ftyp", 16 + i);
+  r.writeString(t.majorBrand), r.writeUint(t.minorVersion, 4);
+  for (const o of t.compatibleBrands) r.writeString(o);
+  return r;
+}
+function As(t) {
+  const o = t.name.length + 1, a = new k("hdlr", 32 + o);
+  return a.writeFullBox(t.version, t.flags), a.writeUint(t.preDefined, 4), a.writeString(t.handlerType), a.writeArray(t.reserved, V, 4, 3), a.writeTerminatedString(t.name), a;
+}
+function ks(t) {
+  const e = new k("mdat", 8 + t.data.length);
+  return e.writeBytes(t.data), e;
+}
+function Ts(t) {
+  const e = t.version === 1 ? 8 : 4, n = 8, s = 4, i = e * 3, r = new k("mdhd", n + s + i + 4 + 2 + 2);
+  r.writeFullBox(t.version, t.flags), r.writeUint(t.creationTime, e), r.writeUint(t.modificationTime, e), r.writeUint(t.timescale, 4), r.writeUint(t.duration, e);
+  const o = t.language.length >= 3 ? (t.language.charCodeAt(0) - 96 & 31) << 10 | (t.language.charCodeAt(1) - 96 & 31) << 5 | t.language.charCodeAt(2) - 96 & 31 : 0;
+  return r.writeUint(o, 2), r.writeUint(t.preDefined, 2), r;
+}
+function Es(t) {
+  const e = new k("mfhd", 16);
+  return e.writeFullBox(t.version, t.flags), e.writeUint(t.sequenceNumber, 4), e;
+}
+function Us(t) {
+  const e = t.version === 1 ? 8 : 4, n = 8, s = 4, i = e * 3, r = new k("mvhd", n + s + i + 4 + 4 + 2 + 2 + 8 + 36 + 24 + 4);
+  return r.writeFullBox(t.version, t.flags), r.writeUint(t.creationTime, e), r.writeUint(t.modificationTime, e), r.writeUint(t.timescale, 4), r.writeUint(t.duration, e), r.writeTemplate(t.rate, 4), r.writeTemplate(t.volume, 2), r.writeUint(t.reserved1, 2), r.writeArray(t.reserved2, V, 4, 2), r.writeArray(t.matrix, le, 4, 9), r.writeArray(t.preDefined, V, 4, 6), r.writeUint(t.nextTrackId, 4), r;
+}
+function Rs(t) {
+  const e = new k("smhd", 16);
+  return e.writeFullBox(t.version, t.flags), e.writeUint(t.balance, 2), e.writeUint(t.reserved, 2), e;
+}
+function Bs(t, e) {
+  const r = t.entries.length, { bytes: o, size: a } = ke(t.entries, e), c = new k("stsd", 16 + a);
+  return c.writeFullBox(t.version, t.flags), c.writeUint(r, 4), c.writeBytes(o), c;
+}
+function xs(t) {
+  const i = t.entryCount * 8, r = new k("stts", 16 + i);
+  r.writeFullBox(t.version, t.flags), r.writeUint(t.entryCount, 4);
+  for (const o of t.entries)
+    r.writeUint(o.sampleCount, 4), r.writeUint(o.sampleDelta, 4);
+  return r;
+}
+function Is(t) {
+  const e = t.version === 1 ? 8 : 4, n = 8, s = 4, i = e, r = new k("tfdt", n + s + i);
+  return r.writeFullBox(t.version, t.flags), r.writeUint(t.baseMediaDecodeTime, e), r;
+}
+function Cs(t) {
+  const i = t.flags & 1 ? 8 : 0, r = t.flags & 2 ? 4 : 0, o = t.flags & 8 ? 4 : 0, a = t.flags & 16 ? 4 : 0, c = t.flags & 32 ? 4 : 0, u = new k("tfhd", 16 + i + r + o + a + c);
+  return u.writeFullBox(t.version, t.flags), u.writeUint(t.trackId, 4), t.flags & 1 && u.writeUint(t.baseDataOffset ?? 0, 8), t.flags & 2 && u.writeUint(t.sampleDescriptionIndex ?? 0, 4), t.flags & 8 && u.writeUint(t.defaultSampleDuration ?? 0, 4), t.flags & 16 && u.writeUint(t.defaultSampleSize ?? 0, 4), t.flags & 32 && u.writeUint(t.defaultSampleFlags ?? 0, 4), u;
+}
+function Ls(t) {
+  const e = t.version === 1 ? 8 : 4, n = 8, s = 4, i = e * 3, r = new k("tkhd", n + s + i + 4 + 4 + 8 + 2 + 2 + 2 + 2 + 36 + 4 + 4);
+  return r.writeFullBox(t.version, t.flags), r.writeUint(t.creationTime, e), r.writeUint(t.modificationTime, e), r.writeUint(t.trackId, 4), r.writeUint(t.reserved1, 4), r.writeUint(t.duration, e), r.writeArray(t.reserved2, V, 4, 2), r.writeUint(t.layer, 2), r.writeUint(t.alternateGroup, 2), r.writeTemplate(t.volume, 2), r.writeUint(t.reserved3, 2), r.writeArray(t.matrix, le, 4, 9), r.writeTemplate(t.width, 4), r.writeTemplate(t.height, 4), r;
+}
+function Os(t) {
+  const e = new k("trex", 32);
+  return e.writeFullBox(t.version, t.flags), e.writeUint(t.trackId, 4), e.writeUint(t.defaultSampleDescriptionIndex, 4), e.writeUint(t.defaultSampleDuration, 4), e.writeUint(t.defaultSampleSize, 4), e.writeUint(t.defaultSampleFlags, 4), e;
+}
+function Ds(t) {
+  const i = t.flags & 1 ? 4 : 0, r = t.flags & 4 ? 4 : 0;
+  let o = 0;
+  t.flags & 256 && (o += 4), t.flags & 512 && (o += 4), t.flags & 1024 && (o += 4), t.flags & 2048 && (o += 4);
+  const a = o * t.sampleCount, c = new k("trun", 16 + i + r + a);
+  c.writeFullBox(t.version, t.flags), c.writeUint(t.sampleCount, 4), t.flags & 1 && c.writeUint(t.dataOffset ?? 0, 4), t.flags & 4 && c.writeUint(t.firstSampleFlags ?? 0, 4);
+  for (const u of t.samples)
+    t.flags & 256 && c.writeUint(u.sampleDuration ?? 0, 4), t.flags & 512 && c.writeUint(u.sampleSize ?? 0, 4), t.flags & 1024 && c.writeUint(u.sampleFlags ?? 0, 4), t.flags & 2048 && c.writeUint(u.sampleCompositionTimeOffset ?? 0, 4);
+  return c;
+}
+function Ps(t) {
+  const s = t.location.length + 1, i = new k("url ", 12 + s);
+  return i.writeFullBox(t.version, t.flags), i.writeTerminatedString(t.location), i;
+}
+function Ns(t) {
+  const e = new k("vmhd", 20);
+  return e.writeFullBox(t.version, t.flags), e.writeUint(t.graphicsmode, 2), e.writeArray(t.opcolor, V, 2, 3), e;
+}
+const zt = {
+  mfhd: bs,
+  tfhd: Ss,
+  tfdt: vs,
+  trun: Ms,
+  mdat: ys
+};
+function Y(t, e) {
+  for (const n of t) {
+    if (e(n))
+      return n;
+    const s = n.boxes;
+    if (s && Array.isArray(s)) {
+      const i = Y(s, e);
+      if (i) return i;
+    }
+  }
+}
+function At(t) {
+  const e = new ArrayBuffer(t.byteLength);
+  return new Uint8Array(e).set(t), e;
+}
+function oe(t) {
+  return (e) => e.type === t;
+}
+function kt(t, e) {
+  const n = _t(At(t), { readers: zt });
+  return (Y(n, oe("tfdt"))?.baseMediaDecodeTime ?? 0) * 1e6 / e;
+}
+function Tt(t, e) {
+  const n = _t(At(t), { readers: zt }), i = Y(n, oe("tfdt"))?.baseMediaDecodeTime ?? 0, r = Y(n, oe("tfhd")), o = r?.defaultSampleDuration ?? 0, a = r?.defaultSampleSize ?? 0, c = r?.defaultSampleFlags ?? 0, u = Y(n, oe("trun"));
+  if (!u)
+    throw new Error("No trun box found in data segment");
+  const l = Y(n, oe("mdat"));
+  if (!l)
+    throw new Error("No mdat box found in data segment");
+  const d = l.data;
+  if (!d)
+    throw new Error("No data in mdat box");
+  const f = [];
+  let g = 0, y = i;
+  for (let b = 0; b < u.sampleCount; b++) {
+    const S = u.samples[b] ?? {}, E = S.sampleSize ?? a, z = S.sampleDuration ?? o;
+    if (E <= 0)
+      throw new Error(`Invalid sample size ${E} for sample ${b} in trun`);
+    if (z <= 0)
+      throw new Error(`Invalid sample duration ${z} for sample ${b} in trun`);
+    if (g + E > d.length)
+      throw new Error(
+        `Sample ${b} would overflow mdat: offset=${g}, size=${E}, mdatLength=${d.length}`
+      );
+    const W = b === 0 && u.firstSampleFlags !== void 0 ? u.firstSampleFlags : S.sampleFlags ?? c, D = S.sampleCompositionTimeOffset ?? 0, P = new Uint8Array(d.slice(g, g + E));
+    g += E;
+    const N = y + D, $ = Math.round(N * 1e6 / e), A = W === 0 || (W & 65536) === 0;
+    f.push({
+      data: P,
+      timestamp: $,
+      keyframe: A
+    }), y += z;
+  }
+  return f;
+}
+function O(t) {
+  if (t = t.startsWith("0x") ? t.slice(2) : t, t.length % 2)
+    throw new Error("invalid hex string length");
+  const e = t.match(/.{2}/g);
+  if (!e)
+    throw new Error("invalid hex string format");
+  return new Uint8Array(e.map((n) => parseInt(n, 16)));
+}
+const we = [65536, 0, 0, 0, 65536, 0, 0, 0, 1073741824], $s = {
+  // Init segment boxes
+  ftyp: zs,
+  mvhd: Us,
+  tkhd: Ls,
+  mdhd: Ts,
+  hdlr: As,
+  vmhd: Ns,
+  smhd: Rs,
+  "url ": Ps,
+  dref: _s,
+  stsd: Bs,
+  stts: xs,
+  trex: Os,
+  // Data segment boxes
+  mfhd: Es,
+  tfhd: Cs,
+  tfdt: Is,
+  trun: Ds,
+  mdat: ks
+  // For boxes without library writers, we create them manually as Uint8Arrays
+};
+function ce(t) {
+  return ws(t, { writers: $s });
+}
+function Te(t, e, n, s) {
+  const i = 12 + s.length, r = new Uint8Array(i), o = new DataView(r.buffer);
+  return o.setUint32(0, i, !1), r[4] = t.charCodeAt(0), r[5] = t.charCodeAt(1), r[6] = t.charCodeAt(2), r[7] = t.charCodeAt(3), o.setUint32(8, e << 24 | n, !1), r.set(s, 12), r;
+}
+function Et() {
+  const t = new Uint8Array(4);
+  return Te("stsc", 0, 0, t);
+}
+function Ut() {
+  const t = new Uint8Array(8);
+  return Te("stsz", 0, 0, t);
+}
+function Rt() {
+  const t = new Uint8Array(4);
+  return Te("stco", 0, 0, t);
+}
+function Fs(t, e, n) {
+  const s = 8 + n.length, r = 8 + (78 + s), o = new Uint8Array(r), a = new DataView(o.buffer);
+  let c = 0;
+  return a.setUint32(c, r, !1), c += 4, o[c++] = 97, o[c++] = 118, o[c++] = 99, o[c++] = 49, c += 6, a.setUint16(c, 1, !1), c += 2, a.setUint16(c, 0, !1), c += 2, a.setUint16(c, 0, !1), c += 2, c += 12, a.setUint16(c, t, !1), c += 2, a.setUint16(c, e, !1), c += 2, a.setUint32(c, 4718592, !1), c += 4, a.setUint32(c, 4718592, !1), c += 4, a.setUint32(c, 0, !1), c += 4, a.setUint16(c, 1, !1), c += 2, c += 32, a.setUint16(c, 24, !1), c += 2, a.setUint16(c, 65535, !1), c += 2, a.setUint32(c, s, !1), c += 4, o[c++] = 97, o[c++] = 118, o[c++] = 99, o[c++] = 67, o.set(n, c), o;
+}
+function qe(t) {
+  const { codedWidth: e, codedHeight: n, description: s, container: i } = t;
+  if (!e || !n || !s)
+    throw new Error("Missing required fields to create video init segment");
+  const r = i.kind === "cmaf" ? i.timescale : 1e6, o = i.kind === "cmaf" ? i.trackId : 1, a = {
+    type: "ftyp",
+    majorBrand: "isom",
+    minorVersion: 512,
+    compatibleBrands: ["isom", "iso6", "mp41"]
+  }, c = {
+    type: "mvhd",
+    version: 0,
+    flags: 0,
+    creationTime: 0,
+    modificationTime: 0,
+    timescale: r,
+    duration: 0,
+    // Unknown/fragmented
+    rate: 65536,
+    // 1.0 in 16.16 fixed point
+    volume: 256,
+    // 1.0 in 8.8 fixed point
+    reserved1: 0,
+    reserved2: [0, 0],
+    matrix: we,
+    preDefined: [0, 0, 0, 0, 0, 0],
+    nextTrackId: o + 1
+  }, u = {
+    type: "tkhd",
+    version: 0,
+    flags: 3,
+    // Track enabled + in movie
+    creationTime: 0,
+    modificationTime: 0,
+    trackId: o,
+    reserved1: 0,
+    duration: 0,
+    reserved2: [0, 0],
+    layer: 0,
+    alternateGroup: 0,
+    volume: 0,
+    // Video tracks have 0 volume
+    reserved3: 0,
+    matrix: we,
+    width: e * 65536,
+    // 16.16 fixed point (avoid << which produces signed int)
+    height: n * 65536
+  }, l = {
+    type: "mdhd",
+    version: 0,
+    flags: 0,
+    creationTime: 0,
+    modificationTime: 0,
+    timescale: r,
+    duration: 0,
+    language: "und",
+    preDefined: 0
+  }, d = {
+    type: "hdlr",
+    version: 0,
+    flags: 0,
+    preDefined: 0,
+    handlerType: "vide",
+    reserved: [0, 0, 0],
+    name: "VideoHandler"
+  }, f = {
+    type: "vmhd",
+    version: 0,
+    flags: 1,
+    // Required to be 1
+    graphicsmode: 0,
+    opcolor: [0, 0, 0]
+  }, b = {
+    type: "dinf",
+    boxes: [{
+      type: "dref",
+      version: 0,
+      flags: 0,
+      entryCount: 1,
+      entries: [{
+        type: "url ",
+        version: 0,
+        flags: 1,
+        // Self-contained flag
+        location: ""
+      }]
+    }]
+  }, E = {
+    type: "stsd",
+    version: 0,
+    flags: 0,
+    entryCount: 1,
+    // biome-ignore lint/suspicious/noExplicitAny: Raw avc1 box since library doesn't handle avcC children
+    entries: [Fs(e, n, O(s))]
+  }, z = {
+    type: "stts",
+    version: 0,
+    flags: 0,
+    entryCount: 0,
+    entries: []
+  }, W = Et(), D = Ut(), P = Rt(), be = ce([a, {
+    type: "moov",
+    boxes: [c, {
+      type: "trak",
+      boxes: [u, {
+        type: "mdia",
+        boxes: [l, d, {
+          type: "minf",
+          boxes: [f, b, {
+            type: "stbl",
+            // biome-ignore lint/suspicious/noExplicitAny: Raw boxes for types without library writers
+            boxes: [E, z, W, D, P]
+          }]
+        }]
+      }]
+    }, {
+      type: "mvex",
+      boxes: [{
+        type: "trex",
+        version: 0,
+        flags: 0,
+        trackId: o,
+        defaultSampleDescriptionIndex: 1,
+        defaultSampleDuration: 0,
+        defaultSampleSize: 0,
+        defaultSampleFlags: 0
+      }]
+    }]
+  }]), de = be.reduce((L, F) => L + F.byteLength, 0), he = new Uint8Array(de);
+  let ne = 0;
+  for (const L of be)
+    he.set(new Uint8Array(L.buffer, L.byteOffset, L.byteLength), ne), ne += L.byteLength;
+  return he;
+}
+function He(t) {
+  const { sampleRate: e, numberOfChannels: n, description: s, codec: i, container: r } = t, o = r.kind === "cmaf" ? r.timescale : 1e6, a = r.kind === "cmaf" ? r.trackId : 1, c = {
+    type: "ftyp",
+    majorBrand: "isom",
+    minorVersion: 512,
+    compatibleBrands: ["isom", "iso6", "mp41"]
+  }, u = {
+    type: "mvhd",
+    version: 0,
+    flags: 0,
+    creationTime: 0,
+    modificationTime: 0,
+    timescale: o,
+    duration: 0,
+    rate: 65536,
+    volume: 256,
+    reserved1: 0,
+    reserved2: [0, 0],
+    matrix: we,
+    preDefined: [0, 0, 0, 0, 0, 0],
+    nextTrackId: a + 1
+  }, l = {
+    type: "tkhd",
+    version: 0,
+    flags: 3,
+    creationTime: 0,
+    modificationTime: 0,
+    trackId: a,
+    reserved1: 0,
+    duration: 0,
+    reserved2: [0, 0],
+    layer: 0,
+    alternateGroup: 0,
+    volume: 256,
+    // Audio tracks have volume (1.0 in 8.8 fixed point)
+    reserved3: 0,
+    matrix: we,
+    width: 0,
+    height: 0
+  }, d = {
+    type: "mdhd",
+    version: 0,
+    flags: 0,
+    creationTime: 0,
+    modificationTime: 0,
+    timescale: o,
+    duration: 0,
+    language: "und",
+    preDefined: 0
+  }, f = {
+    type: "hdlr",
+    version: 0,
+    flags: 0,
+    preDefined: 0,
+    handlerType: "soun",
+    reserved: [0, 0, 0],
+    name: "SoundHandler"
+  }, g = {
+    type: "smhd",
+    version: 0,
+    flags: 0,
+    balance: 0,
+    reserved: 0
+  }, S = {
+    type: "dinf",
+    boxes: [{
+      type: "dref",
+      version: 0,
+      flags: 0,
+      entryCount: 1,
+      entries: [{
+        type: "url ",
+        version: 0,
+        flags: 1,
+        location: ""
+      }]
+    }]
+  }, z = {
+    type: "stsd",
+    version: 0,
+    flags: 0,
+    entryCount: 1,
+    // biome-ignore lint/suspicious/noExplicitAny: Raw sample entry box
+    entries: [js(i, e, n, s)]
+  }, W = {
+    type: "stts",
+    version: 0,
+    flags: 0,
+    entryCount: 0,
+    entries: []
+  }, D = Et(), P = Ut(), N = Rt(), de = ce([c, {
+    type: "moov",
+    boxes: [u, {
+      type: "trak",
+      boxes: [l, {
+        type: "mdia",
+        boxes: [d, f, {
+          type: "minf",
+          boxes: [g, S, {
+            type: "stbl",
+            // biome-ignore lint/suspicious/noExplicitAny: Raw boxes for types without library writers
+            boxes: [z, W, D, P, N]
+          }]
+        }]
+      }]
+    }, {
+      type: "mvex",
+      boxes: [{
+        type: "trex",
+        version: 0,
+        flags: 0,
+        trackId: a,
+        defaultSampleDescriptionIndex: 1,
+        defaultSampleDuration: 0,
+        defaultSampleSize: 0,
+        defaultSampleFlags: 0
+      }]
+    }]
+  }]), he = de.reduce((F, Nt) => F + Nt.byteLength, 0), ne = new Uint8Array(he);
+  let L = 0;
+  for (const F of de)
+    ne.set(new Uint8Array(F.buffer, F.byteOffset, F.byteLength), L), L += F.byteLength;
+  return ne;
+}
+function js(t, e, n, s) {
+  if (t.startsWith("mp4a"))
+    return Zs(e, n, s);
+  if (t === "opus")
+    return Vs(e, n, s);
+  throw new Error(`Unsupported audio codec: ${t}`);
+}
+function Zs(t, e, n) {
+  const s = qs(t, e, n), r = 8 + (28 + s.length), o = new Uint8Array(r), a = new DataView(o.buffer);
+  let c = 0;
+  return a.setUint32(c, r, !1), c += 4, o[c++] = 109, o[c++] = 112, o[c++] = 52, o[c++] = 97, c += 6, a.setUint16(c, 1, !1), c += 2, c += 8, a.setUint16(c, e, !1), c += 2, a.setUint16(c, 16, !1), c += 2, a.setUint16(c, 0, !1), c += 2, a.setUint16(c, 0, !1), c += 2, a.setUint32(c, t * 65536, !1), c += 4, o.set(s, c), o;
+}
+function Vs(t, e, n) {
+  const s = Hs(e, t, n), r = 8 + (28 + s.length), o = new Uint8Array(r), a = new DataView(o.buffer);
+  let c = 0;
+  return a.setUint32(c, r, !1), c += 4, o[c++] = 79, o[c++] = 112, o[c++] = 117, o[c++] = 115, c += 6, a.setUint16(c, 1, !1), c += 2, c += 8, a.setUint16(c, e, !1), c += 2, a.setUint16(c, 16, !1), c += 2, a.setUint16(c, 0, !1), c += 2, a.setUint16(c, 0, !1), c += 2, a.setUint32(c, t * 65536, !1), c += 4, o.set(s, c), o;
+}
+function Ws(t, e) {
+  const s = {
+    96e3: 0,
+    88200: 1,
+    64e3: 2,
+    48e3: 3,
+    44100: 4,
+    32e3: 5,
+    24e3: 6,
+    22050: 7,
+    16e3: 8,
+    12e3: 9,
+    11025: 10,
+    8e3: 11,
+    7350: 12
+  }[t] ?? 4, r = 2 << 3 | s >> 1, o = (s & 1) << 7 | e << 3;
+  return new Uint8Array([r, o]);
+}
+function qs(t, e, n) {
+  const s = n ? O(n) : Ws(t, e), i = s.length, r = 15 + i, o = 5 + r + 3, a = 14 + o, c = new Uint8Array(a), u = new DataView(c.buffer);
+  let l = 0;
+  return u.setUint32(l, a, !1), l += 4, c[l++] = 101, c[l++] = 115, c[l++] = 100, c[l++] = 115, u.setUint32(l, 0, !1), l += 4, c[l++] = 3, c[l++] = o, u.setUint16(l, 0, !1), l += 2, c[l++] = 0, c[l++] = 4, c[l++] = r, c[l++] = 64, c[l++] = 21, c[l++] = 0, c[l++] = 0, c[l++] = 0, u.setUint32(l, 0, !1), l += 4, u.setUint32(l, 0, !1), l += 4, c[l++] = 5, c[l++] = i, c.set(s, l), l += i, c[l++] = 6, c[l++] = 1, c[l++] = 2, c;
+}
+function Hs(t, e, n) {
+  if (n) {
+    const a = O(n), c = 8 + a.length, u = new Uint8Array(c);
+    return new DataView(u.buffer).setUint32(0, c, !1), u[4] = 100, u[5] = 79, u[6] = 112, u[7] = 115, u.set(a, 8), u;
+  }
+  const s = 19, i = new Uint8Array(s), r = new DataView(i.buffer);
+  let o = 0;
+  return r.setUint32(o, s, !1), o += 4, i[o++] = 100, i[o++] = 79, i[o++] = 112, i[o++] = 115, i[o++] = 0, i[o++] = t, r.setUint16(o, 312, !1), o += 2, r.setUint32(o, e, !1), o += 4, r.setInt16(o, 0, !1), o += 2, i[o++] = 0, i;
+}
+function Bt(t) {
+  const { data: e, timestamp: n, duration: s, keyframe: i, sequence: r, trackId: o = 1 } = t, a = i ? 33554432 : 16842752, c = {
+    type: "mfhd",
+    version: 0,
+    flags: 0,
+    sequenceNumber: r
+  }, u = {
+    type: "tfhd",
+    version: 0,
+    flags: 131072,
+    trackId: o
+  }, l = {
+    type: "tfdt",
+    version: 1,
+    // version 1 for 64-bit baseMediaDecodeTime
+    flags: 0,
+    baseMediaDecodeTime: n
+  }, d = {
+    type: "trun",
+    version: 0,
+    flags: 1793,
+    sampleCount: 1,
+    dataOffset: 0,
+    // Will be calculated after we know moof size
+    samples: [
+      {
+        sampleDuration: s,
+        sampleSize: e.byteLength,
+        sampleFlags: a
+      }
+    ]
+  }, g = {
+    type: "moof",
+    boxes: [c, {
+      type: "traf",
+      boxes: [u, l, d]
+    }]
+  }, y = ce([g]);
+  let b = 0;
+  for (const A of y)
+    b += A.byteLength;
+  d.dataOffset = b + 8;
+  const S = ce([g]);
+  b = 0;
+  for (const A of S)
+    b += A.byteLength;
+  const E = new ArrayBuffer(e.byteLength), z = new Uint8Array(E);
+  z.set(e);
+  const D = ce([{
+    type: "mdat",
+    data: z
+  }]);
+  let P = 0;
+  for (const A of D)
+    P += A.byteLength;
+  const N = new Uint8Array(b + P);
+  let $ = 0;
+  for (const A of S)
+    N.set(new Uint8Array(A.buffer, A.byteOffset, A.byteLength), $), $ += A.byteLength;
+  for (const A of D)
+    N.set(new Uint8Array(A.buffer, A.byteOffset, A.byteLength), $), $ += A.byteLength;
+  return N;
+}
+class te {
+  #e;
+  #t;
+  #n = [];
+  #s;
+  // the active group sequence number
+  // Wake up the consumer when a new frame is available.
+  #i;
+  #r = new h([]);
+  buffered = this.#r;
+  #o = new T();
+  constructor(e, n) {
+    this.#e = e, this.#t = h.from(n?.latency ?? M.Time.Milli.zero), this.#o.spawn(this.#a.bind(this)), this.#o.cleanup(() => {
+      this.#e.close();
+      for (const s of this.#n)
+        s.consumer.close();
+      this.#n.length = 0;
+    });
+  }
+  async #a() {
+    for (; ; ) {
+      const e = await this.#e.nextGroup();
+      if (!e) break;
+      if (this.#s === void 0 && (this.#s = e.sequence), e.sequence < this.#s) {
+        console.warn(`skipping old group: ${e.sequence} < ${this.#s}`), e.close();
+        continue;
+      }
+      const n = {
+        consumer: e,
+        frames: []
+      };
+      this.#n.push(n), this.#n.sort((s, i) => s.consumer.sequence - i.consumer.sequence), this.#o.spawn(this.#c.bind(this, n));
+    }
+  }
+  async #c(e) {
+    try {
+      let n = !0;
+      for (; ; ) {
+        const s = await e.consumer.readFrame();
+        if (!s) break;
+        const { data: i, timestamp: r } = te.#d(s), o = {
+          data: i,
+          timestamp: r,
+          keyframe: n
+        };
+        n = !1, e.frames.push(o), (e.latest === void 0 || r > e.latest) && (e.latest = r), this.#l(), e.consumer.sequence === this.#s ? (this.#i?.(), this.#i = void 0) : this.#u();
+      }
+    } catch {
+    } finally {
+      e.done = !0, e.consumer.sequence === this.#s && (this.#s += 1), this.#l(), this.#i?.(), this.#i = void 0, e.consumer.close();
+    }
+  }
+  #u() {
+    if (this.#s === void 0) return;
+    let e = !1;
+    for (; this.#n.length >= 2; ) {
+      const n = M.Time.Micro.fromMilli(this.#t.peek());
+      let s, i;
+      for (const a of this.#n) {
+        if (a.latest === void 0) continue;
+        const c = a.frames.at(0)?.timestamp ?? a.latest;
+        (s === void 0 || c < s) && (s = c), (i === void 0 || a.latest > i) && (i = a.latest);
+      }
+      if (s === void 0 || i === void 0 || i - s <= n) break;
+      const o = this.#n.shift();
+      if (!o) break;
+      this.#s = this.#n[0]?.consumer.sequence, console.warn(`skipping slow group: ${o.consumer.sequence} -> ${this.#s}`), o.consumer.close(), o.frames.length = 0, e = !0;
+    }
+    e && (this.#l(), this.#i?.(), this.#i = void 0);
+  }
+  // Returns the next frame in order, along with the group number.
+  // If frame is undefined, the group is done.
+  async next() {
+    for (; ; ) {
+      if (this.#n.length > 0 && this.#s !== void 0 && this.#n[0].consumer.sequence <= this.#s) {
+        const n = this.#n[0].frames.shift();
+        if (n)
+          return this.#l(), { frame: n, group: this.#n[0].consumer.sequence };
+        if (this.#s > this.#n[0].consumer.sequence || this.#n[0].done) {
+          this.#n[0].consumer.sequence === this.#s && (this.#s += 1);
+          const s = this.#n.shift();
+          if (s)
+            return this.#l(), { frame: void 0, group: s.consumer.sequence };
+        }
+      }
+      if (this.#i)
+        throw new Error("multiple calls to decode not supported");
+      const e = new Promise((n) => {
+        this.#i = n;
+      }).then(() => !0);
+      if (!await Promise.race([e, this.#o.closed])) {
+        this.#i = void 0;
+        return;
+      }
+    }
+  }
+  // NOTE: A keyframe is always the first frame in a group, so it's not encoded on the wire.
+  static #d(e) {
+    const [n, s] = M.Varint.decode(e);
+    return { timestamp: n, data: s };
+  }
+  #l() {
+    const e = [];
+    let n;
+    for (const s of this.#n) {
+      const i = s.frames.at(0);
+      if (!i || s.latest === void 0) continue;
+      const r = M.Time.Milli.fromMicro(i.timestamp), o = M.Time.Milli.fromMicro(s.latest), a = e.at(-1), c = n?.done && n.consumer.sequence + 1 === s.consumer.sequence;
+      a && (a.end >= r || c) ? a.end = M.Time.Milli.max(a.end, o) : e.push({ start: r, end: o }), n = s;
+    }
+    this.#r.set(e);
+  }
+  close() {
+    this.#o.close();
+    for (const e of this.#n)
+      e.consumer.close(), e.frames.length = 0;
+    this.#n.length = 0;
+  }
+}
+let Se;
+async function Ge() {
+  return globalThis.AudioEncoder && globalThis.AudioDecoder ? !0 : (Se || (console.warn("using Opus polyfill; performance may be degraded"), Se = Promise.all([
+    import("./libav-opus-af-BlMWboA7.js"),
+    import("./main-DGBFe0O7.js")
+  ]).then(async ([t, e]) => (await e.load({
+    LibAV: t,
+    polyfill: !0
+  }), !0))), await Se);
+}
+const j = 0, C = 1, se = 2, G = 3, Gs = 4;
+function xt(t, e, n) {
+  if (t <= 0) throw new Error("invalid channels");
+  if (e <= 0) throw new Error("invalid capacity");
+  if (n <= 0) throw new Error("invalid sample rate");
+  const s = new SharedArrayBuffer(t * e * Float32Array.BYTES_PER_ELEMENT), i = new SharedArrayBuffer(Gs * Int32Array.BYTES_PER_ELEMENT), r = new Int32Array(i);
+  return Atomics.store(r, G, 1), { channels: t, capacity: e, rate: n, samples: s, control: i };
+}
+function Xs(t, e) {
+  return (t - e | 0) > 0 ? t : e;
+}
+function ie(t, e) {
+  return (t % e + e) % e;
+}
+function Me(t, e, n) {
+  for (; ; ) {
+    const s = Atomics.load(t, e);
+    if ((n - s | 0) <= 0) return s;
+    if (Atomics.compareExchange(t, e, s, n) === s) return n;
+  }
+}
+class Ee {
+  channels;
+  capacity;
+  rate;
+  init;
+  #e;
+  #t;
+  constructor(e) {
+    this.channels = e.channels, this.capacity = e.capacity, this.rate = e.rate, this.init = e, this.#e = new Int32Array(e.control), this.#t = [];
+    for (let n = 0; n < this.channels; n++)
+      this.#t.push(
+        new Float32Array(e.samples, n * this.capacity * Float32Array.BYTES_PER_ELEMENT, this.capacity)
+      );
+  }
+  /**
+   * Insert audio samples at the given timestamp.
+   * Main thread only. Handles out-of-order writes, gap filling, and overflow.
+   */
+  insert(e, n) {
+    if (n.length !== this.channels) throw new Error("wrong number of channels");
+    let s = Math.round(m.Second.fromMicro(e) * this.rate);
+    const i = n[0].length;
+    let r = 0;
+    const o = s + i | 0, a = Atomics.load(this.#e, C), c = a - s | 0;
+    if (c > 0) {
+      if (c >= i)
+        return;
+      r = c, s = s + c | 0;
+    }
+    const u = i - r;
+    (o - a | 0) > this.capacity && Me(this.#e, C, o - this.capacity | 0);
+    const l = Atomics.load(this.#e, j), d = s - l | 0;
+    if (d > 0) {
+      const b = Math.min(d, this.capacity);
+      for (let S = 0; S < this.channels; S++) {
+        const E = this.#t[S];
+        for (let z = 0; z < b; z++)
+          E[ie(l + z | 0, this.capacity)] = 0;
+      }
+    }
+    for (let b = 0; b < this.channels; b++) {
+      const S = n[b], E = this.#t[b];
+      for (let z = 0; z < u; z++)
+        E[ie(s + z | 0, this.capacity)] = S[r + z];
+    }
+    Atomics.store(this.#e, j, Xs(Atomics.load(this.#e, j), o));
+    const f = Atomics.load(this.#e, C), g = Atomics.load(this.#e, j), y = Atomics.load(this.#e, se);
+    (g - f | 0) >= y && y > 0 && Atomics.store(this.#e, G, 0);
+  }
+  /**
+   * Read audio samples into the output buffers.
+   * AudioWorklet only. Returns the number of samples read.
+   */
+  read(e) {
+    if (Atomics.load(this.#e, G) === 1) return 0;
+    let n = Atomics.load(this.#e, C);
+    const s = Atomics.load(this.#e, j), i = Atomics.load(this.#e, se), r = s - n | 0;
+    if (i > 0 && r > i) {
+      const c = s - i | 0;
+      n = Me(this.#e, C, c);
+    }
+    const o = s - n | 0, a = Math.min(o, e[0].length);
+    if (a <= 0) return 0;
+    for (let c = 0; c < this.channels; c++) {
+      const u = this.#t[c], l = e[c];
+      for (let d = 0; d < a; d++)
+        l[d] = u[ie(n + d | 0, this.capacity)];
+    }
+    return Me(this.#e, C, n + a | 0), a;
+  }
+  /** Update the target latency in samples. */
+  setLatency(e) {
+    Atomics.store(this.#e, se, e);
+  }
+  /**
+   * Allocate a new ring with `newCapacity` samples and copy the unread window
+   * [READ, WRITE) plus control state into it. Used when growing capacity so
+   * we don't drop buffered audio. If `newCapacity` is smaller than the unread
+   * span, the oldest samples are truncated.
+   *
+   * Main thread only. `resize()` reads from the source `SharedRingBuffer` and
+   * writes into a freshly allocated buffer from `allocSharedRingBuffer`, so it
+   * relies on the same invariant as `insert()`: no concurrent main-thread
+   * writers. The AudioWorklet reader is tolerated via the CAS discipline used
+   * by READ/WRITE elsewhere.
+   */
+  resize(e) {
+    const n = xt(this.channels, e, this.rate), s = new Ee(n), i = Atomics.load(this.#e, C), r = Atomics.load(this.#e, j), o = Atomics.load(this.#e, se), a = Atomics.load(this.#e, G), c = r - i | 0, u = Math.max(0, Math.min(c, s.capacity)), l = r - u | 0;
+    for (let d = 0; d < this.channels; d++) {
+      const f = this.#t[d], g = s.#t[d];
+      for (let y = 0; y < u; y++) {
+        const b = l + y | 0;
+        g[ie(b, s.capacity)] = f[ie(b, this.capacity)];
+      }
+    }
+    return Atomics.store(s.#e, C, l), Atomics.store(s.#e, j, r), Atomics.store(s.#e, se, o), Atomics.store(s.#e, G, a), s;
+  }
+  /** Current playback timestamp derived from READ position. */
+  get timestamp() {
+    const e = Atomics.load(this.#e, C);
+    return m.Micro.fromSecond(e / this.rate);
+  }
+  /** Whether the buffer is stalled (waiting to fill). */
+  get stalled() {
+    return Atomics.load(this.#e, G) === 1;
+  }
+  /**
+   * Number of buffered samples (WRITE - READ).
+   *
+   * Non-atomic: WRITE and READ are loaded separately, so a concurrent
+   * writer/reader can make the two loads inconsistent. Intended for
+   * tests and diagnostics, not control-flow decisions.
+   */
+  get length() {
+    return Atomics.load(this.#e, j) - Atomics.load(this.#e, C) | 0;
+  }
+}
+function Ys() {
+  return !(typeof SharedArrayBuffer > "u" || typeof crossOriginIsolated < "u" && !crossOriginIsolated);
+}
+function Ks(t, e, n, s) {
+  return Ys() ? (console.log("[audio] using SharedArrayBuffer audio buffer"), new Js(t, e, n, s)) : (console.log("[audio] using postMessage audio buffer (SharedArrayBuffer unavailable)"), new Qs(t, e, n, s));
+}
+class Js {
+  rate;
+  channels;
+  #e;
+  #t;
+  #n = new h(0);
+  timestamp = this.#n;
+  #s = new h(!0);
+  stalled = this.#s;
+  #i = new T();
+  constructor(e, n, s, i) {
+    this.#e = e, this.channels = n, this.rate = s;
+    const r = Math.max(s, i * 2), o = xt(n, r, s);
+    this.#t = new Ee(o), this.#t.setLatency(i);
+    const a = { type: "init-shared", ...o };
+    e.port.postMessage(a), this.#i.interval(() => {
+      this.#n.set(this.#t.timestamp), this.#s.set(this.#t.stalled);
+    }, 50);
+  }
+  insert(e, n) {
+    this.#t.insert(e, n);
+  }
+  setLatency(e) {
+    if (this.#t.capacity < e * 1.5) {
+      const n = Math.max(this.rate, e * 2);
+      this.#t = this.#t.resize(n), this.#t.setLatency(e);
+      const s = { type: "init-shared", ...this.#t.init };
+      this.#e.port.postMessage(s);
+    } else
+      this.#t.setLatency(e);
+  }
+  close() {
+    this.#i.close();
+  }
+}
+class Qs {
+  rate;
+  channels;
+  #e;
+  #t = new h(0);
+  timestamp = this.#t;
+  #n = new h(!0);
+  stalled = this.#n;
+  #s = new T();
+  constructor(e, n, s, i) {
+    this.#e = e, this.channels = n, this.rate = s;
+    const r = m.Milli.fromSecond(i / s), o = { type: "init-post", channels: n, rate: s, latency: r };
+    e.port.postMessage(o), this.#s.event(e.port, "message", (a) => {
+      const c = a.data;
+      c?.type === "state" && (this.#t.set(c.timestamp), this.#n.set(c.stalled));
+    }), e.port.start();
+  }
+  insert(e, n) {
+    const s = { type: "data", data: n, timestamp: e };
+    this.#e.port.postMessage(
+      s,
+      n.map((i) => i.buffer)
+    );
+  }
+  setLatency(e) {
+    const s = { type: "latency", latency: m.Milli.fromSecond(e / this.rate) };
+    this.#e.port.postMessage(s);
+  }
+  close() {
+    this.#s.close();
+  }
+}
+const ei = `var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../lite/src/path.ts
+var init_path = __esm({
+  "../lite/src/path.ts"() {
+    "use strict";
+  }
+});
+
+// ../lite/src/varint.ts
+var MAX_U6, MAX_U14, MAX_U30, MAX_U53, MAX_U64, MAX_U62;
+var init_varint = __esm({
+  "../lite/src/varint.ts"() {
+    "use strict";
+    MAX_U6 = 2 ** 6 - 1;
+    MAX_U14 = 2 ** 14 - 1;
+    MAX_U30 = 2 ** 30 - 1;
+    MAX_U53 = Number.MAX_SAFE_INTEGER;
+    MAX_U64 = (1n << 64n) - 1n;
+    MAX_U62 = 2n ** 62n - 1n;
+  }
+});
+
+// ../lite/src/index.ts
+init_path();
+
+// ../lite/src/time.ts
+var time_exports = {};
+__export(time_exports, {
+  Micro: () => Micro,
+  Milli: () => Milli,
+  Nano: () => Nano,
+  Second: () => Second
+});
+var Nano = {
+  zero: 0,
+  fromMicro: (us) => us * 1e3,
+  fromMilli: (ms) => ms * 1e6,
+  fromSecond: (s) => s * 1e9,
+  toMicro: (ns) => ns / 1e3,
+  toMilli: (ns) => ns / 1e6,
+  toSecond: (ns) => ns / 1e9,
+  now: () => performance.now() * 1e6,
+  add: (a, b) => a + b,
+  sub: (a, b) => a - b,
+  mul: (a, b) => a * b,
+  div: (a, b) => a / b,
+  max: (a, b) => Math.max(a, b),
+  min: (a, b) => Math.min(a, b)
+};
+var Micro = {
+  zero: 0,
+  fromNano: (ns) => ns / 1e3,
+  fromMilli: (ms) => ms * 1e3,
+  fromSecond: (s) => s * 1e6,
+  toNano: (us) => us * 1e3,
+  toMilli: (us) => us / 1e3,
+  toSecond: (us) => us / 1e6,
+  now: () => performance.now() * 1e3,
+  add: (a, b) => a + b,
+  sub: (a, b) => a - b,
+  mul: (a, b) => a * b,
+  div: (a, b) => a / b,
+  max: (a, b) => Math.max(a, b),
+  min: (a, b) => Math.min(a, b)
+};
+var Milli = {
+  zero: 0,
+  fromNano: (ns) => ns / 1e6,
+  fromMicro: (us) => us / 1e3,
+  fromSecond: (s) => s * 1e3,
+  toNano: (ms) => ms * 1e6,
+  toMicro: (ms) => ms * 1e3,
+  toSecond: (ms) => ms / 1e3,
+  now: () => performance.now(),
+  add: (a, b) => a + b,
+  sub: (a, b) => a - b,
+  mul: (a, b) => a * b,
+  div: (a, b) => a / b,
+  max: (a, b) => Math.max(a, b),
+  min: (a, b) => Math.min(a, b)
+};
+var Second = {
+  zero: 0,
+  fromNano: (ns) => ns / 1e9,
+  fromMicro: (us) => us / 1e6,
+  fromMilli: (ms) => ms / 1e3,
+  toNano: (s) => s * 1e9,
+  toMicro: (s) => s * 1e6,
+  toMilli: (s) => s * 1e3,
+  now: () => performance.now() / 1e3,
+  add: (a, b) => a + b,
+  sub: (a, b) => a - b,
+  mul: (a, b) => a * b,
+  div: (a, b) => a / b,
+  max: (a, b) => Math.max(a, b),
+  min: (a, b) => Math.min(a, b)
+};
+
+// ../lite/src/index.ts
+init_varint();
+
+// src/audio/ring-buffer.ts
+var AudioRingBuffer = class {
+  #buffer;
+  #writeIndex = 0;
+  #readIndex = 0;
+  rate;
+  channels;
+  #stalled = true;
+  constructor(props) {
+    if (props.channels <= 0) throw new Error("invalid channels");
+    if (props.rate <= 0) throw new Error("invalid sample rate");
+    if (props.latency <= 0) throw new Error("invalid latency");
+    const samples = Math.ceil(props.rate * time_exports.Second.fromMilli(props.latency));
+    if (samples === 0) throw new Error("empty buffer");
+    this.rate = props.rate;
+    this.channels = props.channels;
+    this.#buffer = [];
+    for (let i = 0; i < this.channels; i++) {
+      this.#buffer[i] = new Float32Array(samples);
+    }
+  }
+  get stalled() {
+    return this.#stalled;
+  }
+  get timestamp() {
+    return time_exports.Micro.fromSecond(this.#readIndex / this.rate);
+  }
+  get length() {
+    return this.#writeIndex - this.#readIndex;
+  }
+  get capacity() {
+    return this.#buffer[0]?.length;
+  }
+  resize(latency) {
+    const newCapacity = Math.ceil(this.rate * time_exports.Second.fromMilli(latency));
+    if (newCapacity === this.capacity) return;
+    if (newCapacity === 0) throw new Error("empty buffer");
+    const newBuffer = [];
+    for (let i = 0; i < this.channels; i++) {
+      newBuffer[i] = new Float32Array(newCapacity);
+    }
+    const samplesToKeep = Math.min(this.length, newCapacity);
+    if (samplesToKeep > 0) {
+      const copyStart = this.#writeIndex - samplesToKeep;
+      for (let channel = 0; channel < this.channels; channel++) {
+        const src = this.#buffer[channel];
+        const dst = newBuffer[channel];
+        for (let i = 0; i < samplesToKeep; i++) {
+          const srcPos = (copyStart + i) % src.length;
+          const dstPos = (copyStart + i) % dst.length;
+          dst[dstPos] = src[srcPos];
+        }
+      }
+    }
+    this.#buffer = newBuffer;
+    this.#readIndex = this.#writeIndex - samplesToKeep;
+    if (samplesToKeep === 0) this.#stalled = true;
+  }
+  write(timestamp, data) {
+    if (data.length !== this.channels) throw new Error("wrong number of channels");
+    let start = Math.round(time_exports.Second.fromMicro(timestamp) * this.rate);
+    let samples = data[0].length;
+    let offset = this.#readIndex - start;
+    if (offset > samples) {
+      return;
+    } else if (offset > 0) {
+      samples -= offset;
+      start += offset;
+    } else {
+      offset = 0;
+    }
+    const end = start + samples;
+    const overflow = end - this.#readIndex - this.#buffer[0].length;
+    if (overflow >= 0) {
+      this.#stalled = false;
+      this.#readIndex += overflow;
+    }
+    if (start > this.#writeIndex) {
+      const gapSize = Math.min(start - this.#writeIndex, this.#buffer[0].length);
+      if (gapSize === 1) {
+        console.warn("floating point inaccuracy detected");
+      }
+      for (let channel = 0; channel < this.channels; channel++) {
+        const dst = this.#buffer[channel];
+        for (let i = 0; i < gapSize; i++) {
+          const writePos = (this.#writeIndex + i) % dst.length;
+          dst[writePos] = 0;
+        }
+      }
+    }
+    for (let channel = 0; channel < this.channels; channel++) {
+      let src = data[channel];
+      src = src.subarray(src.length - samples);
+      const dst = this.#buffer[channel];
+      if (src.length !== samples) throw new Error("mismatching number of samples");
+      for (let i = 0; i < samples; i++) {
+        const writePos = (start + i) % dst.length;
+        dst[writePos] = src[i];
+      }
+    }
+    if (end > this.#writeIndex) {
+      this.#writeIndex = end;
+    }
+  }
+  read(output) {
+    if (output.length !== this.channels) throw new Error("wrong number of channels");
+    if (this.#stalled) return 0;
+    const samples = Math.min(this.#writeIndex - this.#readIndex, output[0].length);
+    if (samples === 0) return 0;
+    for (let channel = 0; channel < this.channels; channel++) {
+      const dst = output[channel];
+      const src = this.#buffer[channel];
+      if (dst.length !== output[0].length) throw new Error("mismatching number of samples");
+      for (let i = 0; i < samples; i++) {
+        const readPos = (this.#readIndex + i) % src.length;
+        dst[i] = src[readPos];
+      }
+    }
+    this.#readIndex += samples;
+    return samples;
+  }
+};
+
+// src/audio/shared-ring-buffer.ts
+var WRITE = 0;
+var READ = 1;
+var LATENCY = 2;
+var STALLED = 3;
+var CONTROL_SLOTS = 4;
+function allocSharedRingBuffer(channels, capacity, rate) {
+  if (channels <= 0) throw new Error("invalid channels");
+  if (capacity <= 0) throw new Error("invalid capacity");
+  if (rate <= 0) throw new Error("invalid sample rate");
+  const samples = new SharedArrayBuffer(channels * capacity * Float32Array.BYTES_PER_ELEMENT);
+  const control = new SharedArrayBuffer(CONTROL_SLOTS * Int32Array.BYTES_PER_ELEMENT);
+  const ctrl = new Int32Array(control);
+  Atomics.store(ctrl, STALLED, 1);
+  return { channels, capacity, rate, samples, control };
+}
+function i32Max(a, b) {
+  return (a - b | 0) > 0 ? a : b;
+}
+function slot(idx, capacity) {
+  return (idx % capacity + capacity) % capacity;
+}
+function casAdvance(arr, idx, candidate) {
+  for (; ; ) {
+    const current = Atomics.load(arr, idx);
+    if ((candidate - current | 0) <= 0) return current;
+    const witnessed = Atomics.compareExchange(arr, idx, current, candidate);
+    if (witnessed === current) return candidate;
+  }
+}
+var SharedRingBuffer = class _SharedRingBuffer {
+  channels;
+  capacity;
+  rate;
+  init;
+  #control;
+  #samples;
+  constructor(init) {
+    this.channels = init.channels;
+    this.capacity = init.capacity;
+    this.rate = init.rate;
+    this.init = init;
+    this.#control = new Int32Array(init.control);
+    this.#samples = [];
+    for (let i = 0; i < this.channels; i++) {
+      this.#samples.push(
+        new Float32Array(init.samples, i * this.capacity * Float32Array.BYTES_PER_ELEMENT, this.capacity)
+      );
+    }
+  }
+  /**
+   * Insert audio samples at the given timestamp.
+   * Main thread only. Handles out-of-order writes, gap filling, and overflow.
+   */
+  insert(timestamp, data) {
+    if (data.length !== this.channels) throw new Error("wrong number of channels");
+    let start = Math.round(time_exports.Second.fromMicro(timestamp) * this.rate);
+    const originalLength = data[0].length;
+    let offset = 0;
+    const end = start + originalLength | 0;
+    const read = Atomics.load(this.#control, READ);
+    const behind = read - start | 0;
+    if (behind > 0) {
+      if (behind >= originalLength) {
+        return;
+      }
+      offset = behind;
+      start = start + behind | 0;
+    }
+    const samples = originalLength - offset;
+    if ((end - read | 0) > this.capacity) {
+      casAdvance(this.#control, READ, end - this.capacity | 0);
+    }
+    const write = Atomics.load(this.#control, WRITE);
+    const gap = start - write | 0;
+    if (gap > 0) {
+      const gapSize = Math.min(gap, this.capacity);
+      for (let channel = 0; channel < this.channels; channel++) {
+        const dst = this.#samples[channel];
+        for (let i = 0; i < gapSize; i++) {
+          dst[slot(write + i | 0, this.capacity)] = 0;
+        }
+      }
+    }
+    for (let channel = 0; channel < this.channels; channel++) {
+      const src = data[channel];
+      const dst = this.#samples[channel];
+      for (let i = 0; i < samples; i++) {
+        dst[slot(start + i | 0, this.capacity)] = src[offset + i];
+      }
+    }
+    Atomics.store(this.#control, WRITE, i32Max(Atomics.load(this.#control, WRITE), end));
+    const currentRead = Atomics.load(this.#control, READ);
+    const currentWrite = Atomics.load(this.#control, WRITE);
+    const latency = Atomics.load(this.#control, LATENCY);
+    if ((currentWrite - currentRead | 0) >= latency && latency > 0) {
+      Atomics.store(this.#control, STALLED, 0);
+    }
+  }
+  /**
+   * Read audio samples into the output buffers.
+   * AudioWorklet only. Returns the number of samples read.
+   */
+  read(output) {
+    if (Atomics.load(this.#control, STALLED) === 1) return 0;
+    let read = Atomics.load(this.#control, READ);
+    const write = Atomics.load(this.#control, WRITE);
+    const latency = Atomics.load(this.#control, LATENCY);
+    const buffered = write - read | 0;
+    if (latency > 0 && buffered > latency) {
+      const skipTo = write - latency | 0;
+      read = casAdvance(this.#control, READ, skipTo);
+    }
+    const available = write - read | 0;
+    const count = Math.min(available, output[0].length);
+    if (count <= 0) return 0;
+    for (let channel = 0; channel < this.channels; channel++) {
+      const src = this.#samples[channel];
+      const dst = output[channel];
+      for (let i = 0; i < count; i++) {
+        dst[i] = src[slot(read + i | 0, this.capacity)];
+      }
+    }
+    casAdvance(this.#control, READ, read + count | 0);
+    return count;
+  }
+  /** Update the target latency in samples. */
+  setLatency(samples) {
+    Atomics.store(this.#control, LATENCY, samples);
+  }
+  /**
+   * Allocate a new ring with \`newCapacity\` samples and copy the unread window
+   * [READ, WRITE) plus control state into it. Used when growing capacity so
+   * we don't drop buffered audio. If \`newCapacity\` is smaller than the unread
+   * span, the oldest samples are truncated.
+   *
+   * Main thread only. \`resize()\` reads from the source \`SharedRingBuffer\` and
+   * writes into a freshly allocated buffer from \`allocSharedRingBuffer\`, so it
+   * relies on the same invariant as \`insert()\`: no concurrent main-thread
+   * writers. The AudioWorklet reader is tolerated via the CAS discipline used
+   * by READ/WRITE elsewhere.
+   */
+  resize(newCapacity) {
+    const init = allocSharedRingBuffer(this.channels, newCapacity, this.rate);
+    const dst = new _SharedRingBuffer(init);
+    const read = Atomics.load(this.#control, READ);
+    const write = Atomics.load(this.#control, WRITE);
+    const latency = Atomics.load(this.#control, LATENCY);
+    const stalled = Atomics.load(this.#control, STALLED);
+    const available = write - read | 0;
+    const copyCount = Math.max(0, Math.min(available, dst.capacity));
+    const copyStart = write - copyCount | 0;
+    for (let channel = 0; channel < this.channels; channel++) {
+      const src = this.#samples[channel];
+      const out = dst.#samples[channel];
+      for (let i = 0; i < copyCount; i++) {
+        const idx = copyStart + i | 0;
+        out[slot(idx, dst.capacity)] = src[slot(idx, this.capacity)];
+      }
+    }
+    Atomics.store(dst.#control, READ, copyStart);
+    Atomics.store(dst.#control, WRITE, write);
+    Atomics.store(dst.#control, LATENCY, latency);
+    Atomics.store(dst.#control, STALLED, stalled);
+    return dst;
+  }
+  /** Current playback timestamp derived from READ position. */
+  get timestamp() {
+    const read = Atomics.load(this.#control, READ);
+    return time_exports.Micro.fromSecond(read / this.rate);
+  }
+  /** Whether the buffer is stalled (waiting to fill). */
+  get stalled() {
+    return Atomics.load(this.#control, STALLED) === 1;
+  }
+  /**
+   * Number of buffered samples (WRITE - READ).
+   *
+   * Non-atomic: WRITE and READ are loaded separately, so a concurrent
+   * writer/reader can make the two loads inconsistent. Intended for
+   * tests and diagnostics, not control-flow decisions.
+   */
+  get length() {
+    return Atomics.load(this.#control, WRITE) - Atomics.load(this.#control, READ) | 0;
+  }
+};
+
+// src/audio/render-worklet.ts
+var Render = class extends AudioWorkletProcessor {
+  // Set after init, depending on which path the main thread chose.
+  #backend;
+  #underflow = 0;
+  #stateCounter = 0;
+  constructor() {
+    super();
+    this.port.onmessage = (event) => {
+      const msg = event.data;
+      if (msg.type === "init-shared") {
+        console.log("[audio-worklet] init-shared: using SharedArrayBuffer path");
+        this.#backend = new SharedRingBuffer(msg);
+        this.#underflow = 0;
+      } else if (msg.type === "init-post") {
+        console.log("[audio-worklet] init-post: using postMessage path");
+        this.#backend = new AudioRingBuffer(msg);
+        this.#underflow = 0;
+      } else if (msg.type === "data") {
+        if (this.#backend instanceof AudioRingBuffer) this.#backend.write(msg.timestamp, msg.data);
+      } else if (msg.type === "latency") {
+        if (this.#backend instanceof AudioRingBuffer) this.#backend.resize(msg.latency);
+      }
+    };
+  }
+  process(_inputs, outputs, _parameters) {
+    const output = outputs[0];
+    const backend = this.#backend;
+    const samplesRead = backend?.read(output) ?? 0;
+    if (samplesRead < output[0].length) {
+      this.#underflow += output[0].length - samplesRead;
+    } else if (this.#underflow > 0 && backend) {
+      console.debug(\`audio underflow: \${Math.round(1e3 * this.#underflow / backend.rate)}ms\`);
+      this.#underflow = 0;
+    }
+    if (backend instanceof AudioRingBuffer) {
+      this.#stateCounter++;
+      if (this.#stateCounter >= 5) {
+        this.#stateCounter = 0;
+        const state = {
+          type: "state",
+          timestamp: backend.timestamp,
+          stalled: backend.stalled
+        };
+        this.port.postMessage(state);
+      }
+    }
+    return true;
+  }
+};
+registerProcessor("render", Render);
+`, ti = new Blob([ei], { type: "application/javascript" }), ni = URL.createObjectURL(ti);
+let si = class {
+  source;
+  enabled;
+  #e = new h(void 0);
+  context = this.#e;
+  // The root of the audio graph, which can be used for custom visualizations.
+  #t = new h(void 0);
+  // Downcast to AudioNode so it matches Publish.Audio
+  root = this.#t;
+  #n = new h(void 0);
+  sampleRate = this.#n;
+  #s = new h(void 0);
+  stats = this.#s;
+  // Current playback timestamp from worklet
+  #i = new h(void 0);
+  timestamp = this.#i;
+  // Whether the audio buffer is stalled (waiting to fill)
+  #r = new h(!0);
+  stalled = this.#r;
+  // Decode buffer: audio sent to worklet but not yet played
+  #o = new h([]);
+  // Combined buffered ranges (network jitter + decode buffer)
+  #a = new h([]);
+  buffered = this.#a;
+  // Audio ring bridging main thread and worklet (shared memory or postMessage transport).
+  #c;
+  #u = new T();
+  constructor(e, n) {
+    this.source = e, this.source.supported.set(ii), this.enabled = h.from(n?.enabled ?? !1), this.#u.run(this.#d.bind(this)), this.#u.run(this.#l.bind(this)), this.#u.run(this.#f.bind(this)), this.#u.run(this.#m.bind(this));
+  }
+  #d(e) {
+    const n = e.get(this.source.config);
+    if (!n) return;
+    const s = n.sampleRate, i = n.numberOfChannels, r = new AudioContext({
+      latencyHint: "interactive",
+      // We don't use real-time because of the buffer.
+      sampleRate: s
+    });
+    e.set(this.#e, r), e.cleanup(() => r.close()), e.spawn(async () => {
+      if (await r.audioWorklet.addModule(ni), r.state === "closed") return;
+      const o = new AudioWorkletNode(r, "render", {
+        channelCount: i,
+        channelCountMode: "explicit",
+        outputChannelCount: [i]
+      });
+      e.cleanup(() => o.disconnect());
+      const a = this.source.sync.buffer.peek(), c = Math.ceil(s * m.Second.fromMilli(a)), u = Ks(o, i, s, c);
+      this.#c = u, e.cleanup(() => {
+        u.close(), this.#c = void 0;
+      }), e.run((l) => {
+        const d = m.Milli.fromMicro(l.get(u.timestamp));
+        this.#i.set(d), this.#y(d);
+      }), e.run((l) => {
+        this.#r.set(l.get(u.stalled));
+      }), e.set(this.#t, o);
+    });
+  }
+  #l(e) {
+    const n = e.getAll([this.enabled, this.#e]);
+    if (!n) return;
+    const [s, i] = n;
+    i.resume();
+  }
+  #f(e) {
+    if (!e.get(this.#t)) return;
+    const s = this.#c;
+    if (!s) return;
+    const i = e.get(this.source.sync.buffer), r = Math.ceil(s.rate * m.Second.fromMilli(i));
+    s.setLatency(r);
+  }
+  #m(e) {
+    if (!e.get(this.enabled)) return;
+    const s = e.get(this.source.broadcast);
+    if (!s) return;
+    const i = e.get(this.source.track);
+    if (!i) return;
+    const r = e.get(this.source.config);
+    if (!r) return;
+    const o = e.get(s.active);
+    if (!o) return;
+    const a = o.subscribe(i, J.audio);
+    e.cleanup(() => a.close()), r.container.kind === "cmaf" ? this.#g(e, a, r) : this.#p(e, a, r);
+  }
+  #p(e, n, s) {
+    const i = new te(n, {
+      latency: this.source.sync.buffer
+    });
+    e.cleanup(() => i.close()), e.run((r) => {
+      const o = r.get(i.buffered), a = r.get(this.#o);
+      this.#a.update(() => ri(o, a));
+    }), e.spawn(async () => {
+      if (!await Ge()) return;
+      let o = 0;
+      const a = new AudioDecoder({
+        output: (u) => {
+          if (o++, o <= 3) {
+            u.close();
+            return;
+          }
+          this.#h(u);
+        },
+        error: (u) => console.error(u)
+      });
+      e.cleanup(() => {
+        a.state !== "closed" && a.close();
+      });
+      const c = s.description ? O(s.description) : void 0;
+      for (a.configure({
+        ...s,
+        description: c
+      }); ; ) {
+        const u = await i.next();
+        if (!u) break;
+        const { frame: l } = u;
+        if (!l) continue;
+        const d = m.Milli.fromMicro(l.timestamp);
+        this.source.sync.received(d, "audio"), this.#s.update((g) => ({
+          bytesReceived: (g?.bytesReceived ?? 0) + l.data.byteLength
+        }));
+        const f = new EncodedAudioChunk({
+          type: l.keyframe ? "key" : "delta",
+          data: l.data,
+          timestamp: l.timestamp
+        });
+        a.decode(f);
+      }
+    });
+  }
+  #g(e, n, s) {
+    if (s.container.kind !== "cmaf") return;
+    const { timescale: i } = s.container, r = s.description ? O(s.description) : void 0;
+    e.run((o) => {
+      const a = o.get(this.#o);
+      this.#a.update(() => a);
+    }), e.spawn(async () => {
+      if (!await Ge()) return;
+      const a = new AudioDecoder({
+        output: (c) => this.#h(c),
+        error: (c) => console.error(c)
+      });
+      for (e.cleanup(() => {
+        a.state !== "closed" && a.close();
+      }), a.configure({
+        codec: s.codec,
+        sampleRate: s.sampleRate,
+        numberOfChannels: s.numberOfChannels,
+        description: r
+      }); ; ) {
+        const c = await n.nextGroup();
+        if (!c) break;
+        e.spawn(async () => {
+          try {
+            for (; ; ) {
+              const u = await c.readFrame();
+              if (!u) break;
+              const l = Tt(u, i);
+              for (const d of l) {
+                const f = m.Milli.fromMicro(d.timestamp);
+                this.source.sync.received(f, "audio"), this.#s.update((y) => ({
+                  bytesReceived: (y?.bytesReceived ?? 0) + d.data.byteLength
+                }));
+                const g = new EncodedAudioChunk({
+                  type: d.keyframe ? "key" : "delta",
+                  data: d.data,
+                  timestamp: d.timestamp
+                });
+                a.decode(g);
+              }
+            }
+          } finally {
+            c.close();
+          }
+        });
+      }
+    });
+  }
+  #h(e) {
+    const n = e.timestamp, s = m.Milli.fromMicro(n), i = this.#c;
+    if (!i) {
+      e.close();
+      return;
+    }
+    const r = e.numberOfFrames / e.sampleRate * 1e6, o = m.Milli.fromMicro(r), a = m.Milli.add(s, o);
+    this.#w(s, a);
+    const c = Math.min(e.numberOfChannels, i.channels), u = [];
+    for (let l = 0; l < c; l++) {
+      const d = new Float32Array(e.numberOfFrames);
+      e.copyTo(d, { format: "f32-planar", planeIndex: l }), u.push(d);
+    }
+    i.insert(n, u), e.close();
+  }
+  #w(e, n) {
+    e > n || this.#o.mutate((s) => {
+      for (const i of s)
+        if (e <= i.end + 1 && n >= i.start) {
+          i.start = m.Milli.min(i.start, e), i.end = m.Milli.max(i.end, n);
+          return;
+        }
+      s.push({ start: e, end: n }), s.sort((i, r) => i.start - r.start);
+    });
+  }
+  #y(e) {
+    this.#o.mutate((n) => {
+      for (; n.length > 0; ) {
+        if (n[0].end >= e) {
+          n[0].start = m.Milli.max(n[0].start, e);
+          break;
+        }
+        n.shift();
+      }
+    });
+  }
+  close() {
+    this.#u.close();
+  }
+};
+async function ii(t) {
+  const e = t.description ? O(t.description) : void 0;
+  return (await AudioDecoder.isConfigSupported({
+    ...t,
+    description: e
+  })).supported ?? !1;
+}
+function ri(t, e) {
+  if (t.length === 0) return e;
+  if (e.length === 0) return t;
+  const n = [], s = [...t, ...e].sort((i, r) => i.start - r.start);
+  for (const i of s) {
+    const r = n.at(-1);
+    r && r.end >= i.start ? r.end = m.Milli.max(r.end, i.end) : n.push({ ...i });
+  }
+  return n;
+}
+const Xe = 1e-3, _e = 0.2;
+class oi {
+  source;
+  volume;
+  muted;
+  // Similar to muted, but controls whether we download audio at all.
+  // That way we can be "muted" but also download audio for visualizations.
+  paused;
+  #e = new T();
+  // The volume to use when unmuted.
+  #t = 0.5;
+  // The gain node used to adjust the volume.
+  #n = new h(void 0);
+  constructor(e, n) {
+    this.source = e, this.volume = h.from(n?.volume ?? 0.5), this.muted = h.from(n?.muted ?? !1), this.paused = h.from(n?.paused ?? n?.muted ?? !1), this.#e.run((s) => {
+      s.get(this.muted) ? (this.#t = this.volume.peek() || 0.5, this.volume.set(0)) : this.volume.set(this.#t);
+    }), this.#e.run((s) => {
+      const i = !s.get(this.paused) && !s.get(this.muted);
+      this.source.enabled.set(i);
+    }), this.#e.run((s) => {
+      const i = s.get(this.volume);
+      this.muted.set(i === 0);
+    }), this.#e.run((s) => {
+      const i = s.get(this.source.root);
+      if (!i) return;
+      const r = new GainNode(i.context, { gain: s.get(this.volume) });
+      i.connect(r), s.set(this.#n, r), s.run((o) => {
+        o.get(this.source.enabled) && (r.connect(i.context.destination), o.cleanup(() => r.disconnect()));
+      });
+    }), this.#e.run((s) => {
+      const i = s.get(this.#n);
+      if (!i) return;
+      s.cleanup(() => i.gain.cancelScheduledValues(i.context.currentTime));
+      const r = s.get(this.volume);
+      r < Xe ? (i.gain.exponentialRampToValueAtTime(Xe, i.context.currentTime + _e), i.gain.setValueAtTime(0, i.context.currentTime + _e + 0.01)) : i.gain.exponentialRampToValueAtTime(r, i.context.currentTime + _e);
+    });
+  }
+  close() {
+    this.#e.close();
+  }
+}
+class It {
+  element;
+  paused;
+  #e;
+  #t = new h(void 0);
+  mediaSource = this.#t;
+  #n = new T();
+  constructor(e, n) {
+    this.element = h.from(n?.element), this.paused = h.from(n?.paused ?? !1), this.#e = e, this.#n.run(this.#s.bind(this)), this.#n.run(this.#i.bind(this)), this.#n.run(this.#r.bind(this)), this.#n.run(this.#o.bind(this)), this.#n.run(this.#a.bind(this));
+  }
+  #s(e) {
+    const n = e.get(this.element);
+    if (!n) return;
+    const s = new MediaSource();
+    n.src = URL.createObjectURL(s), e.cleanup(() => URL.revokeObjectURL(n.src)), e.event(
+      s,
+      "sourceopen",
+      () => {
+        e.set(this.#t, s);
+      },
+      { once: !0 }
+    ), e.event(s, "error", (i) => {
+      console.error("[MSE] MediaSource error event:", i);
+    });
+  }
+  #i(e) {
+    const n = e.get(this.element);
+    if (!n || e.get(this.paused)) return;
+    const i = m.Milli.toSecond(e.get(this.#e.buffer));
+    e.interval(() => {
+      const r = n.buffered;
+      if (r.length === 0) return;
+      const a = r.end(r.length - 1) - i, c = a - n.currentTime;
+      (c > 0.1 || c < -0.1) && (console.warn("seeking", c > 0 ? "forward" : "backward", Math.abs(c).toFixed(3), "seconds"), n.currentTime = a);
+    }, 100);
+  }
+  #r(e) {
+    const n = e.get(this.element);
+    if (!n) return;
+    const s = e.get(this.mediaSource);
+    s && e.interval(async () => {
+      for (const i of s.sourceBuffers) {
+        for (; i.updating; )
+          await new Promise((r) => i.addEventListener("updateend", r, { once: !0 }));
+        n.currentTime > 10 && i.remove(0, n.currentTime - 10);
+      }
+    }, 1e3);
+  }
+  #o(e) {
+    const n = e.get(this.element);
+    if (!n) return;
+    const s = e.get(this.paused);
+    s && !n.paused ? n.pause() : !s && n.paused && n.play().catch((i) => {
+      console.error("[MSE] MediaElement play error:", i);
+    });
+  }
+  // Seek to the target position based on the reference and latency.
+  #a(e) {
+    const n = e.get(this.element);
+    if (!n || e.get(this.paused)) return;
+    const i = e.get(this.#e.reference);
+    if (i === void 0) return;
+    const r = e.get(this.#e.buffer), o = m.Milli.sub(m.Milli.sub(m.Milli.now(), i), r);
+    n.currentTime = m.Milli.toSecond(o);
+  }
+  close() {
+    this.#n.close();
+  }
+}
+const xi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Muxer: It
+}, Symbol.toStringTag, { value: "Module" })), ai = 20, Ye = 100;
+class Ue {
+  // The earliest time we've received a frame, relative to its timestamp.
+  // This will keep being updated as we catch up to the live playhead then will be relatively static.
+  #e = new h(void 0);
+  reference = this.#e;
+  // The latency setting: "real-time" auto-computes jitter from RTT, a number sets a fixed jitter.
+  latency;
+  // The jitter buffer in milliseconds (always numeric).
+  // In "real-time" mode this is updated automatically from RTT.
+  // When latency is a number, jitter equals that number.
+  jitter;
+  // Any additional delay required for audio or video.
+  audio;
+  video;
+  // The total buffer required: jitter + max(audio, video).
+  #t = new h(m.Milli.zero);
+  buffer = this.#t;
+  // A ghetto way to learn when the reference/buffer changes.
+  // There's probably a way to use Effect, but lets keep it simple for now.
+  #n;
+  // The media timestamp of the most recently received frame.
+  timestamp = new h(void 0);
+  // Per-label late-frame tracking: accumulate count and max lateness, flush on recovery.
+  #s = /* @__PURE__ */ new Map();
+  // RTT signal from the connection (PROBE or getStats).
+  rtt;
+  // Minimum RTT seen, used as the baseline for jitter calculation.
+  // Avoids inflating jitter due to bufferbloat.
+  #i;
+  signals = new T();
+  constructor(e) {
+    this.latency = h.from(e?.latency ?? "real-time"), this.jitter = new h(Ye), this.rtt = e?.rtt, this.audio = h.from(e?.audio), this.video = h.from(e?.video), this.#n = Promise.withResolvers(), this.signals.run(this.#r.bind(this)), this.signals.run(this.#o.bind(this));
+  }
+  #r(e) {
+    const n = e.get(this.latency);
+    if (typeof n == "number") {
+      this.#i = void 0, this.jitter.set(n);
+      return;
+    }
+    if (this.rtt) {
+      const s = e.get(this.rtt);
+      if (s !== void 0) {
+        this.#i = this.#i !== void 0 ? Math.min(this.#i, s) : s;
+        const i = Math.max(ai, this.#i * 1.25);
+        this.jitter.set(i);
+        return;
+      }
+    }
+    this.#i = void 0, this.jitter.set(Ye);
+  }
+  #o(e) {
+    const n = e.get(this.jitter), s = e.get(this.video) ?? m.Milli.zero, i = e.get(this.audio) ?? m.Milli.zero, r = m.Milli.add(m.Milli.max(s, i), n);
+    this.#t.set(r), this.#n.resolve(), this.#n = Promise.withResolvers();
+  }
+  // Update the reference if this is the earliest frame we've seen, relative to its timestamp.
+  received(e, n = "") {
+    this.timestamp.update((o) => o === void 0 || e > o ? e : o);
+    const s = m.Milli.now(), i = m.Milli.sub(s, e), r = this.#e.peek();
+    if (r !== void 0) {
+      const o = m.Milli.add(m.Milli.sub(r, i), this.#t.peek());
+      if (o < 0) {
+        const a = this.#s.get(n);
+        a ? (a.count++, a.maxMs = Math.max(a.maxMs, -o)) : this.#s.set(n, { count: 1, maxMs: -o });
+      } else {
+        const a = this.#s.get(n);
+        if (a) {
+          const c = n ? `sync[${n}]` : "sync", u = Ue.#a(a.maxMs);
+          console.debug(`${c}: ${a.count} late frame(s), max ${u} behind`), this.#s.delete(n);
+        }
+      }
+      if (i >= r)
+        return;
+    }
+    this.#e.set(i), this.#n.resolve(), this.#n = Promise.withResolvers();
+  }
+  // The PTS that should be rendering right now, derived from the reference + buffer.
+  // Returns undefined if no frames have been received yet.
+  now() {
+    const e = this.#e.peek();
+    if (e !== void 0)
+      return m.Milli.sub(m.Milli.sub(m.Milli.now(), e), this.#t.peek());
+  }
+  // Sleep until it's time to render this frame.
+  async wait(e) {
+    if (this.#e.peek() === void 0)
+      throw new Error("reference not set; call update() first");
+    for (; ; ) {
+      const s = m.Milli.now(), i = m.Milli.sub(s, e), r = this.#e.peek();
+      if (r === void 0) return;
+      const o = m.Milli.add(m.Milli.sub(r, i), this.#t.peek());
+      if (o <= 0 || o < 5) return;
+      const a = new Promise((u) => setTimeout(u, o)).then(() => !0);
+      if (await Promise.race([this.#n.promise, a])) return;
+    }
+  }
+  static #a(e) {
+    if (e = Math.round(e), e < 1e3) return `${e}ms`;
+    const n = e / 1e3;
+    if (n < 60) return `${Math.round(n * 10) / 10}s`;
+    const s = n / 60;
+    return `${Math.round(s * 10) / 10}m`;
+  }
+  close() {
+    this.signals.close();
+  }
+}
+const ci = 500, ui = 100;
+class li {
+  enabled;
+  // Don't download any longer
+  source;
+  // The current track running, held so we can cancel it when the new track is ready.
+  #e = new h(void 0);
+  // Expose the current frame to render as a signal
+  #t = new h(void 0);
+  frame = this.#t;
+  // The timestamp of the current frame.
+  #n = new h(void 0);
+  timestamp = this.#n;
+  // The display size of the video in pixels, ideally sourced from the catalog.
+  #s = new h(void 0);
+  display = this.#s;
+  #i = new h(!1);
+  stalled = this.#i;
+  #r = new h(void 0);
+  stats = this.#r;
+  // Combined buffered ranges (network jitter + decode buffer)
+  #o = new h([]);
+  buffered = this.#o;
+  #a = new T();
+  constructor(e, n) {
+    this.enabled = h.from(n?.enabled ?? !1), this.source = e, this.source.supported.set(fi), this.#a.run(this.#c.bind(this)), this.#a.run(this.#u.bind(this)), this.#a.run(this.#d.bind(this)), this.#a.run(this.#l.bind(this));
+  }
+  #c(e) {
+    const n = e.getAll([this.enabled, this.source.broadcast, this.source.track, this.source.config]);
+    if (!n) {
+      this.#e.set(void 0);
+      return;
+    }
+    const [s, i, r, o] = n, a = e.get(i.active);
+    if (!a) return;
+    let c = new di({
+      source: this.source,
+      broadcast: a,
+      track: r,
+      config: o,
+      stats: this.#r
+    });
+    e.cleanup(() => c?.close()), e.run((u) => {
+      if (!c) return;
+      const l = u.get(this.#e);
+      if (l) {
+        const d = u.get(c.timestamp), f = u.get(l.timestamp);
+        if (!d || f && f > d + ui) return;
+      }
+      this.#e.set(c), c = void 0, u.close();
+    });
+  }
+  #u(e) {
+    const n = e.get(this.#e);
+    if (!n) {
+      this.#o.set([]);
+      return;
+    }
+    e.cleanup(() => n.close()), e.run((s) => {
+      const i = s.get(n.frame);
+      this.#t.update((r) => (r?.close(), i?.clone()));
+    }), e.proxy(this.#n, n.timestamp), e.proxy(this.#o, n.buffered);
+  }
+  #d(e) {
+    const n = e.get(this.source.catalog);
+    if (!n) return;
+    const s = n.display;
+    if (s) {
+      e.set(this.#s, {
+        width: s.width,
+        height: s.height
+      });
+      return;
+    }
+    const i = e.get(this.frame);
+    i && e.set(this.#s, {
+      width: i.displayWidth,
+      height: i.displayHeight
+    });
+  }
+  #l(e) {
+    if (!e.get(this.enabled)) return;
+    if (!e.get(this.frame)) {
+      this.#i.set(!0);
+      return;
+    }
+    this.#i.set(!1), e.timer(() => {
+      this.#i.set(!0);
+    }, ci);
+  }
+  close() {
+    this.#t.update((e) => {
+      e?.close();
+    }), this.#a.close();
+  }
+}
+class di {
+  source;
+  broadcast;
+  track;
+  config;
+  stats;
+  timestamp = new h(void 0);
+  frame = new h(void 0);
+  // Network jitter + decode buffer.
+  buffered = new h([]);
+  // Decoded frames waiting to be rendered.
+  #e = new h([]);
+  signals = new T();
+  constructor(e) {
+    const { codedWidth: n, codedHeight: s, ...i } = e.config;
+    this.source = e.source, this.broadcast = e.broadcast, this.track = e.track, this.config = i, this.stats = e.stats, this.signals.run(this.#t.bind(this));
+  }
+  #t(e) {
+    const n = this.broadcast.subscribe(this.track, J.video);
+    e.cleanup(() => n.close());
+    const s = new VideoDecoder({
+      output: async (i) => {
+        try {
+          const r = m.Milli.fromMicro(i.timestamp);
+          if (r < (this.timestamp.peek() ?? 0))
+            return;
+          this.frame.peek() === void 0 && this.frame.set(i.clone());
+          const o = this.source.sync.wait(r).then(() => !0);
+          if (!await Promise.race([o, e.cancel]) || r < (this.timestamp.peek() ?? 0))
+            return;
+          this.timestamp.set(r), this.#r(r), this.frame.update((c) => (c?.close(), i.clone()));
+        } finally {
+          i.close();
+        }
+      },
+      // TODO bubble up error
+      error: (i) => {
+        console.error(i), e.close();
+      }
+    });
+    e.cleanup(() => {
+      s.state !== "closed" && s.close();
+    }), this.config.container.kind === "cmaf" ? this.#s(e, n, s) : this.#n(e, n, s);
+  }
+  #n(e, n, s) {
+    const i = new te(n, {
+      latency: this.source.sync.buffer
+    });
+    e.cleanup(() => i.close()), e.run((o) => {
+      const a = o.get(i.buffered), c = o.get(this.#e);
+      this.buffered.update(() => hi(a, c));
+    }), s.configure({
+      ...this.config,
+      description: this.config.description ? O(this.config.description) : void 0,
+      optimizeForLatency: this.config.optimizeForLatency ?? !0,
+      // @ts-expect-error Only supported by Chrome, so the renderer has to flip manually.
+      flip: !1
+    });
+    let r;
+    e.spawn(async () => {
+      for (; ; ) {
+        const o = await Promise.race([i.next(), e.cancel]);
+        if (!o) break;
+        const { frame: a, group: c } = o;
+        if (!a) {
+          r && (r.final = !0);
+          continue;
+        }
+        const u = m.Milli.fromMicro(a.timestamp);
+        this.source.sync.received(u, "video");
+        const l = new EncodedVideoChunk({
+          type: a.keyframe ? "key" : "delta",
+          data: a.data,
+          timestamp: a.timestamp
+        });
+        if (this.stats.update((d) => ({
+          frameCount: (d?.frameCount ?? 0) + 1,
+          bytesReceived: (d?.bytesReceived ?? 0) + a.data.byteLength
+        })), r?.group === c || r?.final && r.group + 1 === c) {
+          const d = m.Milli.fromMicro(r.timestamp), f = m.Milli.fromMicro(a.timestamp);
+          this.#i(d, f);
+        }
+        r = {
+          timestamp: a.timestamp,
+          group: c,
+          final: !1
+        }, s.decode(l);
+      }
+    });
+  }
+  #s(e, n, s) {
+    if (this.config.container.kind !== "cmaf") return;
+    const { timescale: i } = this.config.container, r = this.config.description ? O(this.config.description) : void 0;
+    s.configure({
+      codec: this.config.codec,
+      description: r,
+      optimizeForLatency: this.config.optimizeForLatency ?? !0,
+      // @ts-expect-error Only supported by Chrome, so the renderer has to flip manually.
+      flip: !1
+    }), e.run((o) => {
+      const a = o.get(this.#e);
+      this.buffered.update(() => a);
+    }), e.spawn(async () => {
+      for (; ; ) {
+        const o = await Promise.race([n.nextGroup(), e.cancel]);
+        if (!o) break;
+        e.spawn(async () => {
+          let a;
+          try {
+            for (; ; ) {
+              const c = await Promise.race([o.readFrame(), e.cancel]);
+              if (!c) break;
+              const u = Tt(c, i);
+              for (const l of u) {
+                const d = new EncodedVideoChunk({
+                  type: l.keyframe ? "key" : "delta",
+                  data: l.data,
+                  timestamp: l.timestamp
+                }), f = m.Milli.fromMicro(l.timestamp);
+                if (this.source.sync.received(f, "video"), this.stats.update((g) => ({
+                  frameCount: (g?.frameCount ?? 0) + 1,
+                  bytesReceived: (g?.bytesReceived ?? 0) + l.data.byteLength
+                })), a !== void 0) {
+                  const g = m.Milli.fromMicro(a), y = m.Milli.fromMicro(l.timestamp);
+                  this.#i(g, y);
+                }
+                a = l.timestamp, s.decode(d);
+              }
+            }
+          } finally {
+            o.close();
+          }
+        });
+      }
+    });
+  }
+  // Add a range to the decode buffer (decoded, waiting to render)
+  #i(e, n) {
+    e > n || this.#e.mutate((s) => {
+      for (const i of s)
+        if (i.start <= n && i.end >= e) {
+          i.start = m.Milli.min(i.start, e), i.end = m.Milli.max(i.end, n);
+          return;
+        }
+      s.push({ start: e, end: n }), s.sort((i, r) => i.start - r.start);
+    });
+  }
+  // Trim the decode buffer up to the rendered timestamp
+  #r(e) {
+    this.#e.mutate((n) => {
+      for (; n.length > 0; ) {
+        if (n[0].end >= e) {
+          n[0].start = m.Milli.max(n[0].start, e);
+          break;
+        }
+        n.shift();
+      }
+    });
+  }
+  close() {
+    this.signals.close(), this.frame.update((e) => {
+      e?.close();
+    });
+  }
+}
+function hi(t, e) {
+  if (t.length === 0) return e;
+  if (e.length === 0) return t;
+  const n = [], s = [...t, ...e].sort((i, r) => i.start - r.start);
+  for (const i of s) {
+    const r = n.at(-1);
+    r && r.end >= i.start ? r.end = m.Milli.max(r.end, i.end) : n.push({ ...i });
+  }
+  return n;
+}
+async function fi(t) {
+  const e = t.description ? O(t.description) : void 0, { supported: n } = await VideoDecoder.isConfigSupported({
+    codec: t.codec,
+    description: e,
+    optimizeForLatency: t.optimizeForLatency ?? !0
+  });
+  if (n) return !0;
+  if (t.codec.startsWith("avc3.")) {
+    const s = `avc1.${t.codec.slice(5)}`;
+    if ((await VideoDecoder.isConfigSupported({
+      codec: s,
+      description: e,
+      optimizeForLatency: t.optimizeForLatency ?? !0
+    })).supported)
+      return t.codec = s, !0;
+  }
+  return !1;
+}
+let mi = class {
+  muxer;
+  source;
+  // TODO implement stats
+  #e = new h(void 0);
+  stats = this.#e;
+  #t = new h([]);
+  buffered = this.#t;
+  #n = new h(!1);
+  stalled = this.#n;
+  #s = new h(M.Time.Milli.zero);
+  timestamp = this.#s;
+  signals = new T();
+  constructor(e, n) {
+    this.muxer = e, this.source = n, this.source.supported.set(pi), this.signals.run(this.#i.bind(this)), this.signals.run(this.#c.bind(this)), this.signals.run(this.#u.bind(this));
+  }
+  #i(e) {
+    const n = e.get(this.muxer.element);
+    if (!n) return;
+    const s = e.get(this.muxer.mediaSource);
+    if (!s) return;
+    const i = e.get(this.source.broadcast);
+    if (!i) return;
+    const r = e.get(i.active);
+    if (!r) return;
+    const o = e.get(this.source.track);
+    if (!o) return;
+    const a = e.get(this.source.config);
+    if (!a) return;
+    const c = `video/mp4; codecs="${a.codec}"`, u = s.addSourceBuffer(c);
+    e.cleanup(() => {
+      s.removeSourceBuffer(u), u.abort();
+    }), e.event(u, "error", (l) => {
+      console.error("[MSE] SourceBuffer error:", l);
+    }), e.event(u, "updateend", () => {
+      this.#t.set(Ct(u.buffered));
+    }), a.container.kind === "cmaf" ? this.#o(e, r, o, a, u, n) : this.#a(e, r, o, a, u, n);
+  }
+  async #r(e, n) {
+    for (; e.updating; )
+      await new Promise((s) => e.addEventListener("updateend", s, { once: !0 }));
+    for (e.appendBuffer(n); e.updating; )
+      await new Promise((s) => e.addEventListener("updateend", s, { once: !0 }));
+  }
+  #o(e, n, s, i, r, o) {
+    if (i.container.kind !== "cmaf") throw new Error("unreachable");
+    const a = n.subscribe(s, J.video);
+    e.cleanup(() => a.close());
+    const c = i.container.timescale;
+    e.spawn(async () => {
+      const u = qe(i);
+      for (await this.#r(r, u); ; ) {
+        const l = await a.readFrame();
+        if (!l) return;
+        const d = kt(l, c);
+        this.source.sync.received(M.Time.Milli.fromMicro(d), "video"), await this.#r(r, l), o.buffered.length > 0 && o.currentTime < o.buffered.start(0) && (o.currentTime = o.buffered.start(0));
+      }
+    });
+  }
+  #a(e, n, s, i, r, o) {
+    const a = n.subscribe(s, J.video);
+    e.cleanup(() => a.close());
+    const c = new te(a, {
+      latency: this.source.sync.buffer
+    });
+    e.cleanup(() => c.close()), e.spawn(async () => {
+      const u = qe(i);
+      await this.#r(r, u);
+      let l = 1, d, f;
+      for (; ; ) {
+        const g = await c.next();
+        if (!g) return;
+        if (!g.frame) continue;
+        f = g.frame;
+        const y = M.Time.Milli.fromMicro(f.timestamp);
+        this.source.sync.received(y, "video");
+        break;
+      }
+      for (; ; ) {
+        const g = await c.next();
+        if (g && !g.frame) continue;
+        const y = g?.frame;
+        if (y) {
+          d = M.Time.Micro.sub(y.timestamp, f.timestamp);
+          const S = M.Time.Milli.fromMicro(y.timestamp);
+          this.source.sync.received(S, "video");
+        }
+        const b = Bt({
+          data: f.data,
+          timestamp: f.timestamp,
+          duration: d ?? 0,
+          // Default to 0 duration if there's literally one frame then stream FIN.
+          keyframe: f.keyframe,
+          sequence: l++
+        });
+        if (await this.#r(r, b), o.buffered.length > 0 && o.currentTime < o.buffered.start(0) && (o.currentTime = o.buffered.start(0)), !y) return;
+        f = y;
+      }
+    });
+  }
+  #c(e) {
+    const n = e.get(this.muxer.element);
+    if (!n) return;
+    const s = () => {
+      this.#n.set(n.readyState <= HTMLMediaElement.HAVE_CURRENT_DATA);
+    };
+    s(), e.event(n, "waiting", s), e.event(n, "playing", s), e.event(n, "seeking", s);
+  }
+  #u(e) {
+    const n = e.get(this.muxer.element);
+    if (n)
+      if ("requestVideoFrameCallback" in n) {
+        const s = n;
+        let i;
+        const r = () => {
+          const o = M.Time.Milli.fromSecond(s.currentTime);
+          this.#s.set(o), i = s.requestVideoFrameCallback(r);
+        };
+        i = s.requestVideoFrameCallback(r), e.cleanup(() => s.cancelVideoFrameCallback(i));
+      } else
+        e.event(n, "timeupdate", () => {
+          const s = M.Time.Milli.fromSecond(n.currentTime);
+          this.#s.set(s);
+        });
+  }
+  close() {
+    this.source.close(), this.signals.close();
+  }
+};
+async function pi(t) {
+  return MediaSource.isTypeSupported(`video/mp4; codecs="${t.codec}"`);
+}
+class gi {
+  decoder;
+  // The canvas to render the video to.
+  canvas;
+  // Whether the video is paused.
+  paused;
+  // The most recently rendered frame, updated after each rAF paint.
+  frame = new h(void 0);
+  // The media timestamp of the most recently rendered frame.
+  timestamp = new h(void 0);
+  #e = new h(void 0);
+  #t = new h(!1);
+  #n = new T();
+  constructor(e, n) {
+    this.decoder = e, this.canvas = h.from(n?.canvas), this.paused = h.from(n?.paused ?? !1), this.#n.run((s) => {
+      const i = s.get(this.canvas);
+      this.#e.set(i?.getContext("2d") ?? void 0);
+    }), this.#n.run(this.#i.bind(this)), this.#n.run(this.#r.bind(this)), this.#n.run(this.#o.bind(this)), this.#n.run(this.#s.bind(this));
+  }
+  #s(e) {
+    const n = e.getAll([this.canvas, this.decoder.display]);
+    if (!n) return;
+    const [s, i] = n;
+    (s.width !== i.width || s.height !== i.height) && (s.width = i.width, s.height = i.height);
+  }
+  // Track whether the canvas is visible in the viewport and the tab is focused.
+  #i(e) {
+    const n = e.get(this.canvas);
+    if (!n) {
+      this.#t.set(!1);
+      return;
+    }
+    let s = !1;
+    const i = () => {
+      this.#t.set(s && !document.hidden);
+    }, r = new IntersectionObserver(
+      (o) => {
+        for (const a of o)
+          s = a.isIntersecting, i();
+      },
+      { threshold: 0.01 }
+    );
+    e.event(document, "visibilitychange", i), r.observe(n), e.cleanup(() => r.disconnect()), e.cleanup(() => this.#t.set(!1));
+  }
+  // Detect when video should be downloaded.
+  #r(e) {
+    const n = e.get(this.paused), s = e.get(this.#t);
+    if (e.cleanup(() => this.decoder.enabled.set(!1)), !n) {
+      this.decoder.enabled.set(s);
+      return;
+    }
+    const i = e.get(this.frame);
+    this.decoder.enabled.set(!i);
+  }
+  #o(e) {
+    const n = e.get(this.#e);
+    if (!n) return;
+    const s = e.get(this.paused);
+    let i;
+    s || (i = e.get(this.decoder.frame));
+    let r = requestAnimationFrame(() => {
+      const o = i ?? this.frame.peek();
+      this.#a(n, o), i && (this.frame.update((a) => (a?.close(), i.clone())), this.timestamp.set(m.Milli.fromMicro(i.timestamp))), r = void 0;
+    });
+    e.cleanup(() => {
+      i?.close(), r && cancelAnimationFrame(r);
+    });
+  }
+  #a(e, n) {
+    if (!n) {
+      e.fillStyle = "#000", e.fillRect(0, 0, e.canvas.width, e.canvas.height);
+      return;
+    }
+    e.save(), e.fillStyle = "#000", e.fillRect(0, 0, e.canvas.width, e.canvas.height), this.decoder.source.catalog.peek()?.flip && (e.scale(-1, 1), e.translate(-e.canvas.width, 0)), e.drawImage(n, 0, 0, e.canvas.width, e.canvas.height), e.restore();
+  }
+  // Close the track and all associated resources.
+  close() {
+    this.frame.update((e) => {
+      e?.close();
+    }), this.#n.close();
+  }
+}
+function wi(t) {
+  return (e) => {
+    const n = [], s = [];
+    for (const [i, r] of e)
+      if (r.codedWidth && r.codedHeight) {
+        const o = r.codedWidth * r.codedHeight;
+        o <= t ? n.push({ name: i, size: o }) : s.push({ name: i, size: o });
+      }
+    return n.sort((i, r) => r.size - i.size), n.length > 0 ? n.map((i) => i.name) : s.length > 0 ? (s.sort((i, r) => i.size - r.size), [s[0].name]) : e.map(([i]) => i);
+  };
+}
+function yi(t) {
+  return (e) => {
+    const n = [], s = [];
+    for (const [i, r] of e)
+      r.bitrate != null && r.bitrate <= t ? n.push({ name: i, bitrate: r.bitrate }) : r.bitrate != null && s.push({ name: i, bitrate: r.bitrate });
+    return n.sort((i, r) => r.bitrate - i.bitrate), n.length > 0 ? n.map((i) => i.name) : s.length > 0 ? (s.sort((i, r) => i.bitrate - r.bitrate), [s[0].name]) : e.map(([i]) => i);
+  };
+}
+function bi(t) {
+  let e = t[0];
+  for (const n of t) {
+    const [, s] = n, [, i] = e, r = (s.codedWidth ?? 0) * (s.codedHeight ?? 0), o = (i.codedWidth ?? 0) * (i.codedHeight ?? 0);
+    if (r !== o) {
+      r > o && (e = n);
+      continue;
+    }
+    (s.bitrate ?? 0) > (i.bitrate ?? 0) && (e = n);
+  }
+  return e[0];
+}
+let vi = class {
+  broadcast;
+  target;
+  #e = new h(void 0);
+  catalog = this.#e;
+  #t = new h({});
+  available = this.#t;
+  // The name of the active rendition.
+  #n = new h(void 0);
+  track = this.#n;
+  #s = new h(void 0);
+  config = this.#s;
+  sync;
+  supported;
+  #i = new T();
+  constructor(e, n) {
+    this.broadcast = h.from(n?.broadcast), this.target = h.from(n?.target), this.sync = e, this.supported = h.from(n?.supported), this.#i.run(this.#r.bind(this)), this.#i.run(this.#o.bind(this)), this.#i.run(this.#a.bind(this));
+  }
+  #r(e) {
+    const n = e.get(this.broadcast);
+    if (!n) return;
+    const s = e.get(n.catalog)?.video;
+    s && e.set(this.#e, s);
+  }
+  #o(e) {
+    const n = e.get(this.supported);
+    if (!n) return;
+    const s = e.get(this.#e)?.renditions ?? {};
+    e.spawn(async () => {
+      const i = {};
+      for (const [r, o] of Object.entries(s))
+        await n(o) && (i[r] = o);
+      Object.keys(i).length === 0 && Object.keys(s).length > 0 && console.warn("[Source] No supported video renditions found:", s), this.#t.set(i);
+    });
+  }
+  #a(e) {
+    const n = e.get(this.#t);
+    if (Object.keys(n).length === 0) return;
+    const s = e.get(this.target);
+    if (s?.name && s.name in n) {
+      const c = n[s.name];
+      e.set(this.#n, s.name), e.set(this.#s, c), e.set(this.sync.video, c.jitter);
+      return;
+    }
+    let i = s;
+    if (!s?.bitrate) {
+      const c = e.get(this.broadcast), l = (c ? e.get(c.connection) : void 0)?.recvBandwidth;
+      if (l) {
+        const d = e.get(l);
+        if (d != null) {
+          const f = Math.round(d * 0.8);
+          i = { ...s, bitrate: f };
+        }
+      }
+    }
+    const r = this.#c(n, i);
+    if (!r) return;
+    const o = n[r];
+    e.set(this.#n, r), e.set(this.#s, o);
+    const a = o.jitter ?? (o.framerate ? Math.ceil(1e3 / o.framerate) : void 0);
+    e.set(this.sync.video, a);
+  }
+  /**
+   * Select the best rendition using a generic filter system.
+   *
+   * Each enabled filter returns matching renditions sorted by preference.
+   * The first rendition present in every filter's output is selected.
+   * If no rendition satisfies all filters, a warning is logged.
+   */
+  #c(e, n) {
+    const s = Object.entries(e);
+    if (s.length === 0) return;
+    if (s.length === 1) return s[0][0];
+    const i = [];
+    if (n?.pixels != null && i.push(wi(n.pixels)), n?.bitrate != null && i.push(yi(n.bitrate)), i.length === 0)
+      return bi(s);
+    const r = i.map((a) => a(s)), o = r.map((a) => new Set(a));
+    for (const a of r[0])
+      if (o.every((c) => c.has(a)))
+        return a;
+    console.warn("conflicting rendition filters, no rendition satisfies all criteria");
+  }
+  close() {
+    this.#i.close();
+  }
+};
+function Ct(t) {
+  const e = [];
+  for (let n = 0; n < t.length; n++) {
+    const s = M.Time.Milli.fromSecond(t.start(n)), i = M.Time.Milli.fromSecond(t.end(n));
+    e.push({ start: s, end: i });
+  }
+  return e;
+}
+class Si {
+  // The source of the video.
+  source;
+  // The stats of the video.
+  stats = new h(void 0);
+  // We're currently stalled waiting for the next frame
+  stalled = new h(!1);
+  // Buffered time ranges
+  buffered = new h([]);
+  // The timestamp of the current frame
+  timestamp = new h(M.Time.Milli.zero);
+  constructor(e) {
+    this.source = e;
+  }
+}
+class Mi {
+  source;
+  // The volume of the audio, between 0 and 1.
+  volume = new h(0.5);
+  // Whether the audio is muted.
+  muted = new h(!1);
+  // The stats of the audio.
+  stats = new h(void 0);
+  // Buffered time ranges
+  buffered = new h([]);
+  constructor(e) {
+    this.source = e;
+  }
+}
+class Li {
+  element = new h(void 0);
+  broadcast;
+  latency;
+  jitter;
+  paused;
+  video;
+  #e;
+  audio;
+  #t;
+  // Used to sync audio and video playback at a target delay.
+  sync;
+  signals = new T();
+  constructor(e) {
+    this.element = h.from(e?.element), this.broadcast = h.from(e?.broadcast), this.sync = new Ue({ latency: e?.latency, rtt: e?.rtt }), this.latency = this.sync.latency, this.jitter = this.sync.jitter, this.#e = new vi(this.sync, {
+      broadcast: this.broadcast
+    }), this.#t = new ki(this.sync, {
+      broadcast: this.broadcast
+    }), this.video = new Si(this.#e), this.audio = new Mi(this.#t), this.paused = h.from(e?.paused ?? !1), this.signals.run(this.#n.bind(this));
+  }
+  #n(e) {
+    const n = e.get(this.element);
+    n && (n instanceof HTMLCanvasElement ? this.#s(e, n) : n instanceof HTMLVideoElement && this.#i(e, n));
+  }
+  #s(e, n) {
+    const s = new li(this.#e), i = new si(this.#t), r = new oi(i, {
+      volume: this.audio.volume,
+      muted: this.audio.muted,
+      paused: this.paused
+    }), o = new gi(s, { canvas: n, paused: this.paused });
+    e.cleanup(() => {
+      s.close(), i.close(), r.close(), o.close();
+    }), e.proxy(this.video.stats, s.stats), e.proxy(this.video.buffered, s.buffered), e.proxy(this.video.stalled, s.stalled), e.proxy(this.video.timestamp, s.timestamp), e.proxy(this.audio.stats, i.stats), e.proxy(this.audio.buffered, i.buffered);
+  }
+  #i(e, n) {
+    const s = new It(this.sync, {
+      paused: this.paused,
+      element: n
+    }), i = new mi(s, this.#e), r = new _i(s, this.#t, {
+      volume: this.audio.volume,
+      muted: this.audio.muted
+    });
+    e.cleanup(() => {
+      i.close(), r.close(), s.close();
+    }), e.proxy(this.video.stats, i.stats), e.proxy(this.video.buffered, i.buffered), e.proxy(this.video.stalled, i.stalled), e.proxy(this.video.timestamp, i.timestamp), e.proxy(this.audio.stats, r.stats), e.proxy(this.audio.buffered, r.buffered);
+  }
+  close() {
+    this.signals.close();
+  }
+}
+class _i {
+  muxer;
+  source;
+  volume;
+  muted;
+  #e = new h(void 0);
+  stats = this.#e;
+  #t = new h([]);
+  buffered = this.#t;
+  #n = new T();
+  constructor(e, n, s) {
+    this.muxer = e, this.source = n, this.source.supported.set(zi), this.volume = h.from(s?.volume ?? 0.5), this.muted = h.from(s?.muted ?? !1), this.#n.run(this.#s.bind(this)), this.#n.run(this.#a.bind(this));
+  }
+  #s(e) {
+    const n = e.get(this.muxer.element);
+    if (!n) return;
+    const s = e.get(this.muxer.mediaSource);
+    if (!s) return;
+    const i = e.get(this.source.broadcast);
+    if (!i) return;
+    const r = e.get(i.active);
+    if (!r) return;
+    const o = e.get(this.source.track);
+    if (!o) return;
+    const a = e.get(this.source.config);
+    if (!a) return;
+    const c = `audio/mp4; codecs="${a.codec}"`, u = s.addSourceBuffer(c);
+    e.cleanup(() => {
+      s.removeSourceBuffer(u), u.abort();
+    }), e.event(u, "error", (d) => {
+      console.error("[MSE] SourceBuffer error:", d);
+    }), e.event(u, "updateend", () => {
+      this.#t.set(Ct(u.buffered));
+    });
+    const l = r.subscribe(o, J.audio);
+    e.cleanup(() => l.close()), a.container.kind === "cmaf" ? this.#r(e, l, a, u, n) : this.#o(e, l, a, u, n);
+  }
+  async #i(e, n) {
+    for (; e.updating; )
+      await new Promise((s) => e.addEventListener("updateend", s, { once: !0 }));
+    for (e.appendBuffer(n); e.updating; )
+      await new Promise((s) => e.addEventListener("updateend", s, { once: !0 }));
+  }
+  #r(e, n, s, i, r) {
+    if (s.container.kind !== "cmaf") throw new Error("unreachable");
+    const o = s.container.timescale;
+    e.spawn(async () => {
+      const a = He(s);
+      for (await this.#i(i, a); ; ) {
+        const c = await n.readFrame();
+        if (!c) return;
+        const u = kt(c, o);
+        this.source.sync.received(M.Time.Milli.fromMicro(u), "audio"), await this.#i(i, c), r.buffered.length > 0 && r.currentTime < r.buffered.start(0) && (r.currentTime = r.buffered.start(0));
+      }
+    });
+  }
+  #o(e, n, s, i, r) {
+    const o = new te(n, {
+      latency: this.source.sync.buffer
+    });
+    e.cleanup(() => o.close()), e.spawn(async () => {
+      const a = He(s);
+      await this.#i(i, a);
+      let c = 1, u, l;
+      for (; ; ) {
+        const d = await o.next();
+        if (!d) return;
+        if (!d.frame) continue;
+        l = d.frame;
+        const f = M.Time.Milli.fromMicro(l.timestamp);
+        this.source.sync.received(f, "audio");
+        break;
+      }
+      for (; ; ) {
+        const d = await o.next();
+        if (d && !d.frame) continue;
+        const f = d?.frame;
+        if (f) {
+          u = M.Time.Micro.sub(f.timestamp, l.timestamp);
+          const y = M.Time.Milli.fromMicro(f.timestamp);
+          this.source.sync.received(y, "audio");
+        }
+        const g = Bt({
+          data: l.data,
+          timestamp: l.timestamp,
+          duration: u ?? 0,
+          // Default to 0 duration if there's literally one frame then stream FIN.
+          keyframe: l.keyframe,
+          sequence: c++
+        });
+        if (await this.#i(i, g), r.buffered.length > 0 && r.currentTime < r.buffered.start(0) && (r.currentTime = r.buffered.start(0)), !f) return;
+        l = f;
+      }
+    });
+  }
+  #a(e) {
+    const n = e.get(this.muxer.element);
+    if (!n) return;
+    const s = e.get(this.volume), i = e.get(this.muted);
+    i && !n.muted ? n.muted = !0 : !i && n.muted && (n.muted = !1), s !== n.volume && (n.volume = s), e.event(n, "volumechange", () => {
+      this.volume.set(n.volume);
+    });
+  }
+  close() {
+    this.#n.close();
+  }
+}
+async function zi(t) {
+  return MediaSource.isTypeSupported(`audio/mp4; codecs="${t.codec}"`);
+}
+const Ai = 128;
+class ki {
+  broadcast;
+  target;
+  #e = new h(void 0);
+  catalog = this.#e;
+  #t = new h({});
+  available = this.#t;
+  #n = new h(void 0);
+  track = this.#n;
+  #s = new h(void 0);
+  config = this.#s;
+  supported;
+  // Used to target a latency and synchronize playback of video with audio.
+  sync;
+  #i = new T();
+  constructor(e, n) {
+    this.sync = e, this.broadcast = h.from(n?.broadcast), this.target = h.from(n?.target), this.supported = h.from(n?.supported), this.#i.run(this.#r.bind(this)), this.#i.run(this.#o.bind(this)), this.#i.run(this.#a.bind(this));
+  }
+  #r(e) {
+    const n = e.get(this.broadcast);
+    if (!n) return;
+    const s = e.get(n.catalog)?.audio;
+    s && e.set(this.#e, s);
+  }
+  #o(e) {
+    const n = e.get(this.#e)?.renditions ?? {}, s = e.get(this.supported);
+    s && e.spawn(async () => {
+      const i = {};
+      for (const [r, o] of Object.entries(n))
+        await s(o) && (i[r] = o);
+      Object.keys(i).length === 0 && Object.keys(n).length > 0 && console.warn("no supported audio renditions found:", n), this.#t.set(i);
+    });
+  }
+  #a(e) {
+    const n = e.get(this.#t);
+    if (Object.keys(n).length === 0) return;
+    const s = e.get(this.target);
+    let i;
+    if (s?.name && s.name in n)
+      i = { track: s.name, config: n[s.name] };
+    else if (i = this.#c(n), !i) return;
+    e.set(this.#n, i.track), e.set(this.#s, i.config);
+    const r = i.config.jitter ?? Ti(i.config) ?? 0, o = Math.ceil(Ai / i.config.sampleRate * 1e3), a = r + o;
+    e.set(this.sync.audio, a);
+  }
+  /**
+   * Select rendition based on the configured strategy.
+   */
+  #c(e) {
+    const n = Object.entries(e);
+    if (n.length !== 0) {
+      for (const [s, i] of n)
+        if (i.container.kind === "legacy")
+          return { track: s, config: i };
+      for (const [s, i] of n)
+        if (i.container.kind === "cmaf")
+          return { track: s, config: i };
+    }
+  }
+  close() {
+    this.#i.close();
+  }
+}
+function Ti(t) {
+  if (t.codec.startsWith("opus"))
+    return 20;
+  if (t.codec.startsWith("mp4a"))
+    return Math.ceil(1024 / t.sampleRate * 1e3);
+}
+class Oi {
+  connection;
+  enabled;
+  name;
+  status = new h("offline");
+  reload;
+  #e = new h(void 0);
+  active = this.#e;
+  #t = new h(void 0);
+  catalog = this.#t;
+  // All actively announced broadcast paths from the connection.
+  #n;
+  signals = new T();
+  constructor(e) {
+    this.connection = h.from(e?.connection), this.name = h.from(e?.name ?? $t.empty()), this.enabled = h.from(e?.enabled ?? !1), this.reload = h.from(e?.reload ?? !1), this.#n = e?.announced ?? new h(/* @__PURE__ */ new Set()), this.signals.run(this.#i.bind(this)), this.signals.run(this.#r.bind(this));
+  }
+  #s(e) {
+    if (!e.get(this.reload)) return !0;
+    const s = e.get(this.name);
+    return e.get(this.#n).has(s);
+  }
+  #i(e) {
+    if (!e.get(this.enabled) || !this.#s(e)) return;
+    const s = e.get(this.connection);
+    if (!s) return;
+    const i = e.get(this.name), r = s.consume(i);
+    e.cleanup(() => r.close()), e.set(this.#e, r, void 0);
+  }
+  #r(e) {
+    const n = e.getAll([this.enabled, this.active]);
+    if (!n) return;
+    const [s, i] = n;
+    this.status.set("loading");
+    const r = i.subscribe("catalog.json", J.catalog);
+    e.cleanup(() => r.close()), e.spawn(async () => {
+      try {
+        for (; ; ) {
+          const o = await Promise.race([e.cancel, ss(r)]);
+          if (!o) break;
+          console.debug("received catalog", this.name.peek(), o), this.#t.set(o), this.status.set("live");
+        }
+      } catch (o) {
+        console.warn("error fetching catalog", this.name.peek(), o);
+      } finally {
+        this.#t.set(void 0), this.status.set("offline");
+      }
+    });
+  }
+  close() {
+    this.signals.close();
+  }
+}
+export {
+  Oi as B,
+  li as D,
+  oi as E,
+  mi as M,
+  J as P,
+  gi as R,
+  vi as S,
+  p as a,
+  ht as b,
+  si as c,
+  _i as d,
+  ki as e,
+  Ri as f,
+  wt as g,
+  Li as h,
+  Ue as i,
+  xi as m,
+  _ as o,
+  v as s,
+  Ct as t
+};
+//# sourceMappingURL=broadcast-BMWX8K5V.js.map