@moqtap/codec 0.4.2 → 0.5.0

package/dist/{chunk-SDWRXXOO.cjs → chunk-HO44OANK.cjs}

@@ -438,8 +438,7 @@ function encodeParams(params, w) {
     const tmpW = new (0, _chunkJL3NEW3Ocjs.BufferWriter)(64);
     tmpW.writeVarInt(at.alias_type);
     tmpW.writeVarInt(at.token_type);
-    const tokenBytes = textEncoder.encode(at.token_value);
-    tmpW.writeBytes(tokenBytes);
+    tmpW.writeBytes(at.token_value);
     const raw = tmpW.finish();
     w.writeVarInt(raw.byteLength);
     w.writeBytes(raw);
@@ -501,7 +500,7 @@ function decodeParams(r) {
         result.authorization_token = {
           alias_type,
           token_type,
-          token_value: textDecoder.decode(tokenBytes)
+          token_value: tokenBytes
         };
       } else {
         const bytes = r.readBytes(length);

package/dist/{chunk-Q46ZURKX.js → chunk-HYI6LFMD.js}

@@ -888,8 +888,7 @@ function encodeAuthorizationToken(token, w) {
   }
   if (aliasType === 1 || aliasType === 3) {
     w.writeVarInt(token.token_type);
-    const tokenBytes = hexToBytes(token.token_value_hex);
-    w.writeBytes(tokenBytes);
+    w.writeBytes(token.token_value);
   }
 }
 function decodeAuthorizationToken(r) {
@@ -902,7 +901,7 @@ function decodeAuthorizationToken(r) {
   if (aliasType === 1 || aliasType === 3) {
     result.token_type = r.readVarInt();
     const tokenBytes = r.readBytesView(r.remaining);
-    result.token_value_hex = bytesToHex(tokenBytes);
+    result.token_value = new Uint8Array(tokenBytes);
   }
   return result;
 }

package/dist/chunk-IWYKDCXP.js

@@ -0,0 +1,446 @@
+// src/drafts/draft18/rules.ts
+var CONTROL_MESSAGES = /* @__PURE__ */ new Set([
+  "setup",
+  "subscribe",
+  "subscribe_ok",
+  "request_update",
+  "publish",
+  "publish_done",
+  "publish_namespace",
+  "namespace",
+  "namespace_done",
+  "subscribe_namespace",
+  "subscribe_tracks",
+  "publish_blocked",
+  "fetch",
+  "fetch_ok",
+  "track_status",
+  "request_ok",
+  "request_error",
+  "goaway"
+]);
+var CLIENT_ONLY_MESSAGES = /* @__PURE__ */ new Set();
+var SERVER_ONLY_MESSAGES = /* @__PURE__ */ new Set();
+var BIDIRECTIONAL_MESSAGES = /* @__PURE__ */ new Set([
+  "setup",
+  "subscribe",
+  "subscribe_ok",
+  "request_update",
+  "publish",
+  "publish_done",
+  "publish_namespace",
+  "namespace",
+  "namespace_done",
+  "subscribe_namespace",
+  "subscribe_tracks",
+  "publish_blocked",
+  "fetch",
+  "fetch_ok",
+  "track_status",
+  "request_ok",
+  "request_error",
+  "goaway"
+]);
+function getLegalOutgoing(phase, _role) {
+  const legal = /* @__PURE__ */ new Set();
+  switch (phase) {
+    case "idle":
+      legal.add("setup");
+      break;
+    case "setup":
+      legal.add("setup");
+      break;
+    case "ready": {
+      for (const msg of BIDIRECTIONAL_MESSAGES) {
+        legal.add(msg);
+      }
+      break;
+    }
+    case "draining":
+      break;
+  }
+  return legal;
+}
+function getLegalIncoming(phase, role) {
+  const remoteRole = role === "client" ? "server" : "client";
+  return getLegalOutgoing(phase, remoteRole);
+}
+
+// src/drafts/draft18/session-fsm.ts
+function violation(code, message, currentPhase, offendingMessage) {
+  return { code, message, currentPhase, offendingMessage };
+}
+var Draft18SessionFSM = class {
+  _phase = "idle";
+  _role;
+  _setupDirection = null;
+  _subscriptions = /* @__PURE__ */ new Map();
+  _publishes = /* @__PURE__ */ new Map();
+  _fetches = /* @__PURE__ */ new Map();
+  _requestIds = /* @__PURE__ */ new Set();
+  _pendingSubscribes = [];
+  _pendingPublishes = [];
+  _pendingFetches = [];
+  constructor(role) {
+    this._role = role;
+  }
+  get phase() {
+    return this._phase;
+  }
+  get role() {
+    return this._role;
+  }
+  get subscriptions() {
+    return this._subscriptions;
+  }
+  get announces() {
+    return /* @__PURE__ */ new Map();
+  }
+  get publishes() {
+    return this._publishes;
+  }
+  get fetches() {
+    return this._fetches;
+  }
+  get legalOutgoing() {
+    return getLegalOutgoing(this._phase, this._role);
+  }
+  get legalIncoming() {
+    return getLegalIncoming(this._phase, this._role);
+  }
+  checkDuplicateRequestId(requestId, msgType) {
+    if (this._requestIds.has(requestId)) {
+      return violation(
+        "DUPLICATE_REQUEST_ID",
+        `Request ID ${requestId} already in use`,
+        this._phase,
+        msgType
+      );
+    }
+    return null;
+  }
+  validateOutgoing(message) {
+    if (!this.legalOutgoing.has(message.type)) {
+      return {
+        ok: false,
+        violation: violation(
+          this._phase === "idle" || this._phase === "setup" ? "MESSAGE_BEFORE_SETUP" : "UNEXPECTED_MESSAGE",
+          `Cannot send ${message.type} in phase ${this._phase}`,
+          this._phase,
+          message.type
+        )
+      };
+    }
+    return { ok: true };
+  }
+  receive(message) {
+    return this.applyTransition(message, "inbound");
+  }
+  send(message) {
+    return this.applyTransition(message, "outbound");
+  }
+  applyTransition(message, direction) {
+    const sideEffects = [];
+    switch (message.type) {
+      case "setup":
+        return this.handleSetup(direction);
+      case "goaway":
+        return this.handleGoAway(message, sideEffects);
+      case "subscribe":
+        return this.handleSubscribe(message, sideEffects);
+      case "subscribe_ok":
+        return this.handleSubscribeOk(message, sideEffects);
+      case "request_update":
+        return this.handleRequestUpdate(message, sideEffects);
+      case "publish":
+        return this.handlePublish(message, sideEffects);
+      case "publish_done":
+        return this.handlePublishDone(message, sideEffects);
+      case "fetch":
+        return this.handleFetch(message, sideEffects);
+      case "fetch_ok":
+        return this.handleFetchOk(sideEffects);
+      case "request_ok":
+        return this.handleRequestOk(sideEffects);
+      case "request_error":
+        return this.handleRequestError(sideEffects);
+      default:
+        return this.handleReadyPhaseMessage(message);
+    }
+  }
+  handleSetup(direction) {
+    if (this._phase === "idle") {
+      this._setupDirection = direction;
+      this._phase = "setup";
+      return { ok: true, phase: this._phase, sideEffects: [] };
+    }
+    if (this._phase === "setup") {
+      if (direction === this._setupDirection) {
+        return {
+          ok: false,
+          violation: violation(
+            "SETUP_VIOLATION",
+            `Second SETUP must be ${this._setupDirection === "inbound" ? "outbound" : "inbound"}, got ${direction}`,
+            this._phase,
+            "setup"
+          )
+        };
+      }
+      this._phase = "ready";
+      return {
+        ok: true,
+        phase: this._phase,
+        sideEffects: [{ type: "session-ready" }]
+      };
+    }
+    return {
+      ok: false,
+      violation: violation(
+        "SETUP_VIOLATION",
+        "SETUP not valid in current phase",
+        this._phase,
+        "setup"
+      )
+    };
+  }
+  handleGoAway(message, sideEffects) {
+    if (this._phase !== "ready" && this._phase !== "draining") {
+      return {
+        ok: false,
+        violation: violation(
+          "UNEXPECTED_MESSAGE",
+          `GOAWAY not valid in phase ${this._phase}`,
+          this._phase,
+          "goaway"
+        )
+      };
+    }
+    this._phase = "draining";
+    const goaway = message;
+    sideEffects.push({
+      type: "session-draining",
+      goAwayUri: goaway.new_session_uri
+    });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  requireReady(msgType) {
+    if (this._phase !== "ready" && this._phase !== "draining") {
+      return violation(
+        this._phase === "idle" || this._phase === "setup" ? "MESSAGE_BEFORE_SETUP" : "UNEXPECTED_MESSAGE",
+        `${msgType} requires ready phase, current: ${this._phase}`,
+        this._phase,
+        msgType
+      );
+    }
+    return null;
+  }
+  handleSubscribe(message, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const sub = message;
+    const dupErr = this.checkDuplicateRequestId(sub.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(sub.request_id);
+    this._subscriptions.set(sub.request_id, {
+      subscribeId: sub.request_id,
+      phase: "pending",
+      trackNamespace: sub.track_namespace,
+      trackName: sub.track_name
+    });
+    this._pendingSubscribes.push(sub.request_id);
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleSubscribeOk(_message, sideEffects) {
+    const err = this.requireReady("subscribe_ok");
+    if (err) return { ok: false, violation: err };
+    const requestId = this._pendingSubscribes.shift();
+    if (requestId === void 0) {
+      return {
+        ok: false,
+        violation: violation(
+          "UNEXPECTED_MESSAGE",
+          "SUBSCRIBE_OK with no pending subscribe",
+          this._phase,
+          "subscribe_ok"
+        )
+      };
+    }
+    const existing = this._subscriptions.get(requestId);
+    if (existing && existing.phase === "pending") {
+      this._subscriptions.set(requestId, { ...existing, phase: "active" });
+      sideEffects.push({
+        type: "subscription-activated",
+        subscribeId: requestId
+      });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleRequestUpdate(message, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const update = message;
+    const dupErr = this.checkDuplicateRequestId(update.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(update.request_id);
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handlePublish(message, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const pub = message;
+    const dupErr = this.checkDuplicateRequestId(pub.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(pub.request_id);
+    this._publishes.set(pub.request_id, {
+      requestId: pub.request_id,
+      phase: "pending"
+    });
+    this._pendingPublishes.push(pub.request_id);
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handlePublishDone(_message, sideEffects) {
+    const err = this.requireReady("publish_done");
+    if (err) return { ok: false, violation: err };
+    for (const [reqId, pub] of this._publishes) {
+      if (pub.phase === "active") {
+        this._publishes.set(reqId, { ...pub, phase: "done" });
+        sideEffects.push({
+          type: "publish-ended",
+          requestId: reqId,
+          reason: "done"
+        });
+        break;
+      }
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleFetch(message, sideEffects) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    const fetch = message;
+    const dupErr = this.checkDuplicateRequestId(fetch.request_id, message.type);
+    if (dupErr) return { ok: false, violation: dupErr };
+    this._requestIds.add(fetch.request_id);
+    this._fetches.set(fetch.request_id, {
+      requestId: fetch.request_id,
+      phase: "pending"
+    });
+    this._pendingFetches.push(fetch.request_id);
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleFetchOk(sideEffects) {
+    const err = this.requireReady("fetch_ok");
+    if (err) return { ok: false, violation: err };
+    const requestId = this._pendingFetches.shift();
+    if (requestId === void 0) {
+      return {
+        ok: false,
+        violation: violation(
+          "UNEXPECTED_MESSAGE",
+          "FETCH_OK with no pending fetch",
+          this._phase,
+          "fetch_ok"
+        )
+      };
+    }
+    const existing = this._fetches.get(requestId);
+    if (existing && existing.phase === "pending") {
+      this._fetches.set(requestId, { ...existing, phase: "active" });
+      sideEffects.push({ type: "fetch-activated", requestId });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleRequestError(sideEffects) {
+    const err = this.requireReady("request_error");
+    if (err) return { ok: false, violation: err };
+    const subId = this.dequeuePending(this._pendingSubscribes, this._subscriptions);
+    if (subId !== void 0) {
+      const sub = this._subscriptions.get(subId);
+      this._subscriptions.set(subId, { ...sub, phase: "error" });
+      sideEffects.push({
+        type: "subscription-ended",
+        subscribeId: subId,
+        reason: "request_error"
+      });
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    const pubId = this.dequeuePending(this._pendingPublishes, this._publishes);
+    if (pubId !== void 0) {
+      const pub = this._publishes.get(pubId);
+      this._publishes.set(pubId, { ...pub, phase: "error" });
+      sideEffects.push({
+        type: "publish-ended",
+        requestId: pubId,
+        reason: "request_error"
+      });
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    const fetchId = this.dequeuePending(this._pendingFetches, this._fetches);
+    if (fetchId !== void 0) {
+      const f = this._fetches.get(fetchId);
+      this._fetches.set(fetchId, { ...f, phase: "error" });
+      sideEffects.push({
+        type: "fetch-ended",
+        requestId: fetchId,
+        reason: "request_error"
+      });
+      return { ok: true, phase: this._phase, sideEffects };
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  handleRequestOk(sideEffects) {
+    const err = this.requireReady("request_ok");
+    if (err) return { ok: false, violation: err };
+    const pubId = this.dequeuePending(this._pendingPublishes, this._publishes);
+    if (pubId !== void 0) {
+      const pub = this._publishes.get(pubId);
+      this._publishes.set(pubId, { ...pub, phase: "active" });
+      sideEffects.push({ type: "publish-activated", requestId: pubId });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+  dequeuePending(queue, stateMap) {
+    while (queue.length > 0) {
+      const id = queue[0];
+      const state = stateMap.get(id);
+      if (state && state.phase === "pending") {
+        queue.shift();
+        return id;
+      }
+      queue.shift();
+    }
+    return void 0;
+  }
+  handleReadyPhaseMessage(message) {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    return { ok: true, phase: this._phase, sideEffects: [] };
+  }
+  reset() {
+    this._phase = "idle";
+    this._setupDirection = null;
+    this._subscriptions.clear();
+    this._publishes.clear();
+    this._fetches.clear();
+    this._requestIds.clear();
+    this._pendingSubscribes.length = 0;
+    this._pendingPublishes.length = 0;
+    this._pendingFetches.length = 0;
+  }
+};
+
+// src/drafts/draft18/session.ts
+function createDraft18SessionState(role) {
+  return new Draft18SessionFSM(role);
+}
+
+export {
+  CONTROL_MESSAGES,
+  CLIENT_ONLY_MESSAGES,
+  SERVER_ONLY_MESSAGES,
+  BIDIRECTIONAL_MESSAGES,
+  getLegalOutgoing,
+  getLegalIncoming,
+  Draft18SessionFSM,
+  createDraft18SessionState
+};

package/dist/{chunk-WPFBK7UX.cjs → chunk-JB5VDJ2V.cjs}

@@ -393,8 +393,7 @@ function encodeSetupParams(params, w) {
     const tmpW = new (0, _chunkJL3NEW3Ocjs.BufferWriter)(64);
     tmpW.writeVarInt(at.alias_type);
     tmpW.writeVarInt(at.token_type);
-    const tokenBytes = textEncoder.encode(at.token_value);
-    tmpW.writeBytes(tokenBytes);
+    tmpW.writeBytes(at.token_value);
     const raw = tmpW.finish();
     w.writeVarInt(raw.byteLength);
     w.writeBytes(raw);
@@ -449,7 +448,7 @@ function decodeSetupParams(r) {
         result.authorization_token = {
           alias_type,
           token_type,
-          token_value: textDecoder.decode(tokenBytes)
+          token_value: tokenBytes
         };
       } else {
         const bytes = r.readBytes(length);
@@ -480,8 +479,7 @@ function encodeParams(params, w) {
     const tmpW = new (0, _chunkJL3NEW3Ocjs.BufferWriter)(64);
     tmpW.writeVarInt(at.alias_type);
     tmpW.writeVarInt(at.token_type);
-    const tokenBytes = textEncoder.encode(at.token_value);
-    tmpW.writeBytes(tokenBytes);
+    tmpW.writeBytes(at.token_value);
     const raw = tmpW.finish();
     w.writeVarInt(raw.byteLength);
     w.writeBytes(raw);
@@ -539,7 +537,7 @@ function decodeParams(r) {
         result.authorization_token = {
           alias_type,
           token_type,
-          token_value: textDecoder.decode(tokenBytes)
+          token_value: tokenBytes
         };
       } else {
         const bytes = r.readBytes(length);

package/dist/{chunk-2SGE5GMU.cjs → chunk-JTRU76JN.cjs}

@@ -830,7 +830,7 @@ function encodeSetupParams(params, writer) {
       tmpWriter.writeVarInt(tok.token_type);
     }
     if (tok.token_value !== void 0) {
-      tmpWriter.writeBytes(_chunkJL3NEW3Ocjs.hexToBytes.call(void 0, tok.token_value));
+      tmpWriter.writeBytes(tok.token_value);
     }
     if (tok.token_alias !== void 0) {
       tmpWriter.writeVarInt(tok.token_alias);
@@ -902,7 +902,7 @@ function decodeSetupParams(reader) {
           tok.token_type = tokenReader.readVarInt();
           if (tokenReader.remaining > 0) {
             const tokenValue = tokenReader.readBytesView(tokenReader.remaining);
-            tok.token_value = _chunkJL3NEW3Ocjs.bytesToHex.call(void 0, tokenValue);
+            tok.token_value = new Uint8Array(tokenValue);
           }
         }
         result.authorization_token = tok;
@@ -942,7 +942,7 @@ function encodeMessageParams(params, writer) {
       tmpWriter.writeVarInt(tok.token_type);
     }
     if (tok.token_value !== void 0) {
-      tmpWriter.writeBytes(_chunkJL3NEW3Ocjs.hexToBytes.call(void 0, tok.token_value));
+      tmpWriter.writeBytes(tok.token_value);
     }
     if (tok.token_alias !== void 0) {
       tmpWriter.writeVarInt(tok.token_alias);
@@ -998,7 +998,7 @@ function decodeMessageParams(reader) {
           tok.token_type = tokenReader.readVarInt();
           if (tokenReader.remaining > 0) {
             const tokenValue = tokenReader.readBytesView(tokenReader.remaining);
-            tok.token_value = _chunkJL3NEW3Ocjs.bytesToHex.call(void 0, tokenValue);
+            tok.token_value = new Uint8Array(tokenValue);
           }
         }
         result.authorization_token = tok;

package/dist/{chunk-TKBYPIN7.js → chunk-NZ7GYEMT.js}

@@ -393,8 +393,7 @@ function encodeSetupParams(params, w) {
     const tmpW = new BufferWriter(64);
     tmpW.writeVarInt(at.alias_type);
     tmpW.writeVarInt(at.token_type);
-    const tokenBytes = textEncoder.encode(at.token_value);
-    tmpW.writeBytes(tokenBytes);
+    tmpW.writeBytes(at.token_value);
     const raw = tmpW.finish();
     w.writeVarInt(raw.byteLength);
     w.writeBytes(raw);
@@ -449,7 +448,7 @@ function decodeSetupParams(r) {
         result.authorization_token = {
           alias_type,
           token_type,
-          token_value: textDecoder.decode(tokenBytes)
+          token_value: tokenBytes
         };
       } else {
         const bytes = r.readBytes(length);
@@ -480,8 +479,7 @@ function encodeParams(params, w) {
     const tmpW = new BufferWriter(64);
     tmpW.writeVarInt(at.alias_type);
     tmpW.writeVarInt(at.token_type);
-    const tokenBytes = textEncoder.encode(at.token_value);
-    tmpW.writeBytes(tokenBytes);
+    tmpW.writeBytes(at.token_value);
     const raw = tmpW.finish();
     w.writeVarInt(raw.byteLength);
     w.writeBytes(raw);
@@ -539,7 +537,7 @@ function decodeParams(r) {
         result.authorization_token = {
           alias_type,
           token_type,
-          token_value: textDecoder.decode(tokenBytes)
+          token_value: tokenBytes
         };
       } else {
         const bytes = r.readBytes(length);

package/dist/{chunk-5O764MBD.cjs → chunk-OGZTQA24.cjs}

@@ -1028,9 +1028,9 @@ function encodeAuthorizationToken(token, w) {
   }
   if (aliasType === 1 || aliasType === 3) {
     w.writeVarInt(_nullishCoalesce(token.token_type, () => ( 0n)));
-    const encoded = textEncoder.encode(_nullishCoalesce(token.token_value, () => ( "")));
-    w.writeVarInt(BigInt(encoded.byteLength));
-    w.writeBytes(encoded);
+    const tv = _nullishCoalesce(token.token_value, () => ( new Uint8Array(0)));
+    w.writeVarInt(BigInt(tv.byteLength));
+    w.writeBytes(tv);
   }
 }
 function decodeAuthorizationToken(r) {
@@ -1046,7 +1046,7 @@ function decodeAuthorizationToken(r) {
     result.token_type = r.readVarInt();
     const len = Number(r.readVarInt());
     const bytes = r.readBytes(len);
-    result.token_value = textDecoder.decode(bytes);
+    result.token_value = bytes;
   }
   return result;
 }
@@ -1261,7 +1261,7 @@ function encodeTrackProperties(props, writer) {
     entries.push({
       type: TPROP_IMMUTABLE_PROPERTIES,
       encode: (w) => {
-        const raw = _chunkJL3NEW3Ocjs.hexToBytes.call(void 0, props.immutable_properties);
+        const raw = props.immutable_properties;
         w.writeVarInt(BigInt(raw.byteLength));
         w.writeBytes(raw);
       }
@@ -1346,7 +1346,7 @@ function decodeTrackProperties(reader, payloadEnd) {
       const length = Number(reader.readVarInt());
       const bytes = reader.readBytes(length);
       if (propType === TPROP_IMMUTABLE_PROPERTIES) {
-        result.immutable_properties = _chunkJL3NEW3Ocjs.bytesToHex.call(void 0, bytes);
+        result.immutable_properties = bytes;
       } else {
         unknown.push({
           id: `0x${propType.toString(16)}`,

package/dist/{chunk-76774UFF.js → chunk-Q5D6OW6Q.js}

@@ -830,7 +830,7 @@ function encodeSetupParams(params, writer) {
       tmpWriter.writeVarInt(tok.token_type);
     }
     if (tok.token_value !== void 0) {
-      tmpWriter.writeBytes(hexToBytes(tok.token_value));
+      tmpWriter.writeBytes(tok.token_value);
     }
     if (tok.token_alias !== void 0) {
       tmpWriter.writeVarInt(tok.token_alias);
@@ -902,7 +902,7 @@ function decodeSetupParams(reader) {
           tok.token_type = tokenReader.readVarInt();
           if (tokenReader.remaining > 0) {
             const tokenValue = tokenReader.readBytesView(tokenReader.remaining);
-            tok.token_value = bytesToHex(tokenValue);
+            tok.token_value = new Uint8Array(tokenValue);
           }
         }
         result.authorization_token = tok;
@@ -942,7 +942,7 @@ function encodeMessageParams(params, writer) {
       tmpWriter.writeVarInt(tok.token_type);
     }
     if (tok.token_value !== void 0) {
-      tmpWriter.writeBytes(hexToBytes(tok.token_value));
+      tmpWriter.writeBytes(tok.token_value);
     }
     if (tok.token_alias !== void 0) {
       tmpWriter.writeVarInt(tok.token_alias);
@@ -998,7 +998,7 @@ function decodeMessageParams(reader) {
           tok.token_type = tokenReader.readVarInt();
           if (tokenReader.remaining > 0) {
             const tokenValue = tokenReader.readBytesView(tokenReader.remaining);
-            tok.token_value = bytesToHex(tokenValue);
+            tok.token_value = new Uint8Array(tokenValue);
           }
         }
         result.authorization_token = tok;

package/dist/{chunk-XS77RBY7.js → chunk-RZ3UML47.js}

@@ -852,8 +852,7 @@ function encodeAuthorizationToken(token, w) {
   }
   if (aliasType === 1 || aliasType === 3) {
     w.writeVarInt(token.token_type);
-    const tokenBytes = hexToBytes(token.token_value_hex);
-    w.writeBytes(tokenBytes);
+    w.writeBytes(token.token_value);
   }
 }
 function decodeAuthorizationToken(r) {
@@ -865,8 +864,7 @@ function decodeAuthorizationToken(r) {
   }
   if (aliasType === 1 || aliasType === 3) {
     result.token_type = r.readVarInt();
-    const tokenBytes = r.readBytesView(r.remaining);
-    result.token_value_hex = bytesToHex(tokenBytes);
+    result.token_value = r.readBytes(r.remaining);
   }
   return result;
 }