@moqtap/codec 0.9.0 → 0.11.0

package/dist/{chunk-KLPWJU6W.js → chunk-YRZQVNZO.js}

@@ -1,3 +1,49 @@
+// src/core/auth-redaction.ts
+var REDACTION_FILL = 0;
+var spans = null;
+function recordAuthValueSpan(start, length) {
+  if (spans === null || length <= 0) return;
+  spans.push(start, length);
+}
+function withoutAuthValueSpans(decode) {
+  const saved = spans;
+  spans = null;
+  try {
+    return decode();
+  } finally {
+    spans = saved;
+  }
+}
+function redactWith(frame, payloadStart, decode) {
+  const outer = spans;
+  spans = [];
+  let captured;
+  let decoded = false;
+  try {
+    decoded = decode();
+  } catch {
+  } finally {
+    captured = spans;
+    spans = outer;
+  }
+  if (captured.length === 0) return { bytes: frame, redacted: 0, incomplete: false, decoded };
+  let out = null;
+  let redacted = 0;
+  let incomplete = false;
+  for (let i = 0; i < captured.length; i += 2) {
+    const start = payloadStart + captured[i];
+    const length = captured[i + 1];
+    if (payloadStart < 0 || start < 0 || start + length > frame.length) {
+      incomplete = true;
+      continue;
+    }
+    if (out === null) out = frame.slice();
+    out.fill(REDACTION_FILL, start, start + length);
+    redacted++;
+  }
+  return { bytes: out ?? frame, redacted, incomplete, decoded };
+}
+
 // src/core/types.ts
 var DecodeError = class extends Error {
   code;
@@ -318,6 +364,10 @@ function hexToBytes(hex) {
 }
 
 export {
+  REDACTION_FILL,
+  recordAuthValueSpan,
+  withoutAuthValueSpans,
+  redactWith,
   DecodeError,
   BufferReader,
   MoqtBufferReader,

package/dist/{codec-Bym-K2q2.d.cts → codec-76xzrLTL.d.cts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
-import { D as Draft20Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft20DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-CWCQwuvy.cjs';
+import { D as Draft20Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft20DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-CwN7AEoL.cjs';
 
 /**
  * `PUBLISH_DONE.Stream Count` "unknown" sentinel — draft-20 Section 10.12.
@@ -45,5 +46,23 @@ interface Draft20Codec extends BaseCodec<Draft20Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft20Codec(): Draft20Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-20 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the tokens were so the caller never has to hold
+ * a frame that contains one. A caller that also wants the message should decode
+ * the **redacted** frame with {@link decodeMessage}, which then cannot produce a
+ * token value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft20Codec as D, UNKNOWN_STREAM_COUNT as U, createStreamDecoder as a, createDraft20Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft20Codec as D, UNKNOWN_STREAM_COUNT as U, createStreamDecoder as a, createDraft20Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-BKsVu3Fr.d.ts → codec-8p40WdLg.d.ts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.js';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
-import { D as Draft12Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft12DataStream } from './types-Bio-91Rt.js';
+import { D as Draft12Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft12DataStream } from './types-CI_SX4Xe.js';
 
 /**
  * Encode a draft-12 control message.
@@ -25,5 +26,23 @@ interface Draft12Codec extends BaseCodec<Draft12Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft12Message>;
 }
 declare function createDraft12Codec(): Draft12Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-12 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft12Codec as D, createStreamDecoder as a, createDraft12Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft12Codec as D, createStreamDecoder as a, createDraft12Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-Dl_QIXMz.d.ts → codec-BN2Bu0KI.d.ts}

@@ -1,3 +1,4 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.js';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
 import { D as Draft08Message, S as SubgroupStream, c as DatagramObject, d as DatagramStatusObject, F as FetchStream, b as Draft08DataStream } from './types-jV1yDDBA.js';
 
@@ -27,5 +28,23 @@ interface Draft08Codec extends BaseCodec<Draft08Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft08Message>;
 }
 declare function createDraft08Codec(): Draft08Codec;
+/**
+ * Overwrite every AUTHORIZATION_INFO value in a draft-08 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft08Codec as D, createStreamDecoder as a, createDraft08Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft08Codec as D, createStreamDecoder as a, createDraft08Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-D4RvFQmu.d.ts → codec-Bb6GKTrv.d.ts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.js';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
-import { D as Draft17Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft17DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-D9eiB_9A.js';
+import { D as Draft17Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft17DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-DAnalt5K.js';
 
 /**
  * Encode a draft-17 control message with type(varint) + length(uint16 BE) + payload.
@@ -26,5 +27,23 @@ interface Draft17Codec extends BaseCodec<Draft17Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft17Codec(): Draft17Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-17 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft17Codec as D, createStreamDecoder as a, createDraft17Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft17Codec as D, createStreamDecoder as a, createDraft17Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-DAyiF5sq.d.cts → codec-BgpfHoAd.d.cts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
-import { D as Draft11Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft11DataStream } from './types-Ck45Ex5S.cjs';
+import { D as Draft11Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft11DataStream } from './types-D0kTgUuL.cjs';
 
 /**
  * Encode a draft-11 control message with type(varint) + length(varint) + payload.
@@ -23,5 +24,23 @@ interface Draft11Codec extends BaseCodec<Draft11Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft11Message>;
 }
 declare function createDraft11Codec(): Draft11Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-11 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft11Codec as D, createStreamDecoder as a, createDraft11Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft11Codec as D, createStreamDecoder as a, createDraft11Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-CA6nbbEk.d.ts → codec-BkheTXO7.d.ts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.js';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
-import { D as Draft11Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft11DataStream } from './types-Ck45Ex5S.js';
+import { D as Draft11Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft11DataStream } from './types-D0kTgUuL.js';
 
 /**
  * Encode a draft-11 control message with type(varint) + length(varint) + payload.
@@ -23,5 +24,23 @@ interface Draft11Codec extends BaseCodec<Draft11Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft11Message>;
 }
 declare function createDraft11Codec(): Draft11Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-11 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft11Codec as D, createStreamDecoder as a, createDraft11Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft11Codec as D, createStreamDecoder as a, createDraft11Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-DchsPfr3.d.cts → codec-BwVDkokh.d.cts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
-import { D as Draft17Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft17DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-D9eiB_9A.cjs';
+import { D as Draft17Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft17DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-DAnalt5K.cjs';
 
 /**
  * Encode a draft-17 control message with type(varint) + length(uint16 BE) + payload.
@@ -26,5 +27,23 @@ interface Draft17Codec extends BaseCodec<Draft17Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft17Codec(): Draft17Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-17 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft17Codec as D, createStreamDecoder as a, createDraft17Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft17Codec as D, createStreamDecoder as a, createDraft17Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-CgZdadPt.d.cts → codec-C5s1eBJX.d.cts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
-import { D as Draft19Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft19DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-zHgCS6o5.cjs';
+import { D as Draft19Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft19DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-Btp416jt.cjs';
 
 /**
  * Encode a draft-18 control message with type(varint) + length(uint16 BE) + payload.
@@ -26,5 +27,23 @@ interface Draft19Codec extends BaseCodec<Draft19Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft19Codec(): Draft19Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-19 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the tokens were so the caller never has to hold
+ * a frame that contains one. A caller that also wants the message should decode
+ * the **redacted** frame with {@link decodeMessage}, which then cannot produce a
+ * token value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft19Codec as D, createStreamDecoder as a, createDraft19Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft19Codec as D, createStreamDecoder as a, createDraft19Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/codec-CM5yd6n3.d.ts

@@ -0,0 +1,38 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.js';
+import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
+import { D as Draft07Message, S as SubgroupStream, b as DatagramObject, F as FetchStream } from './types-Dl4IaAHR.js';
+
+interface Draft07Codec extends BaseCodec<Draft07Message> {
+    readonly draft: '07';
+    encodeVarInt(value: number | bigint): Uint8Array;
+    decodeVarInt(bytes: Uint8Array, offset?: number): DecodeResult<bigint>;
+    encodeSubgroupStream(stream: SubgroupStream): Uint8Array;
+    decodeSubgroupStream(bytes: Uint8Array): DecodeResult<SubgroupStream>;
+    encodeDatagram(dg: DatagramObject): Uint8Array;
+    decodeDatagram(bytes: Uint8Array): DecodeResult<DatagramObject>;
+    encodeFetchStream(stream: FetchStream): Uint8Array;
+    decodeFetchStream(bytes: Uint8Array): DecodeResult<FetchStream>;
+    createStreamDecoder(): TransformStream<Uint8Array, Draft07Message>;
+}
+declare function createDraft07Codec(): Draft07Codec;
+
+/**
+ * Overwrite every AUTHORIZATION_INFO value in a draft-07 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
+
+export { type Draft07Codec as D, createDraft07Codec as c, redactAuthTokens as r };

package/dist/{codec-DJmqoIsp.d.cts → codec-Cb8HC3XV.d.cts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
-import { D as Draft16Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft16DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-Cm9fjeYC.cjs';
+import { D as Draft16Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft16DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-BxTL1NXw.cjs';
 
 /**
  * Encode a draft-16 control message with type(varint) + length(uint16 BE) + payload.
@@ -26,5 +27,23 @@ interface Draft16Codec extends BaseCodec<Draft16Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft16Codec(): Draft16Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-16 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft16Codec as D, createStreamDecoder as a, createDraft16Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft16Codec as D, createStreamDecoder as a, createDraft16Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/codec-Clu_skx8.d.cts

@@ -0,0 +1,38 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
+import { D as Draft07Message, S as SubgroupStream, b as DatagramObject, F as FetchStream } from './types-Dl4IaAHR.cjs';
+
+interface Draft07Codec extends BaseCodec<Draft07Message> {
+    readonly draft: '07';
+    encodeVarInt(value: number | bigint): Uint8Array;
+    decodeVarInt(bytes: Uint8Array, offset?: number): DecodeResult<bigint>;
+    encodeSubgroupStream(stream: SubgroupStream): Uint8Array;
+    decodeSubgroupStream(bytes: Uint8Array): DecodeResult<SubgroupStream>;
+    encodeDatagram(dg: DatagramObject): Uint8Array;
+    decodeDatagram(bytes: Uint8Array): DecodeResult<DatagramObject>;
+    encodeFetchStream(stream: FetchStream): Uint8Array;
+    decodeFetchStream(bytes: Uint8Array): DecodeResult<FetchStream>;
+    createStreamDecoder(): TransformStream<Uint8Array, Draft07Message>;
+}
+declare function createDraft07Codec(): Draft07Codec;
+
+/**
+ * Overwrite every AUTHORIZATION_INFO value in a draft-07 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
+
+export { type Draft07Codec as D, createDraft07Codec as c, redactAuthTokens as r };

package/dist/{codec-DzkdW4kO.d.cts → codec-CpOpemR8.d.cts}

@@ -1,3 +1,4 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
 import { D as Draft08Message, S as SubgroupStream, c as DatagramObject, d as DatagramStatusObject, F as FetchStream, b as Draft08DataStream } from './types-jV1yDDBA.cjs';
 
@@ -27,5 +28,23 @@ interface Draft08Codec extends BaseCodec<Draft08Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft08Message>;
 }
 declare function createDraft08Codec(): Draft08Codec;
+/**
+ * Overwrite every AUTHORIZATION_INFO value in a draft-08 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft08Codec as D, createStreamDecoder as a, createDraft08Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft08Codec as D, createStreamDecoder as a, createDraft08Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-CXCjya_G.d.cts → codec-Cshdl9Tt.d.cts}

@@ -1,3 +1,4 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
 import { D as Draft09Message, S as SubgroupStream, c as DatagramObject, d as DatagramStatusObject, F as FetchStream, b as Draft09DataStream } from './types-B3g5G9KP.cjs';
 
@@ -19,5 +20,23 @@ interface Draft09Codec extends BaseCodec<Draft09Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft09Message>;
 }
 declare function createDraft09Codec(): Draft09Codec;
+/**
+ * Overwrite every AUTHORIZATION_INFO value in a draft-09 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft09Codec as D, createStreamDecoder as a, createDraft09Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft09Codec as D, createStreamDecoder as a, createDraft09Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-CSBFdPgP.d.cts → codec-DELe00w_.d.cts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
-import { D as Draft18Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft18DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-Cqp10JtB.cjs';
+import { D as Draft18Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft18DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-DxXNP32l.cjs';
 
 /**
  * Encode a draft-18 control message with type(varint) + length(uint16 BE) + payload.
@@ -26,5 +27,23 @@ interface Draft18Codec extends BaseCodec<Draft18Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft18Codec(): Draft18Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-18 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft18Codec as D, createStreamDecoder as a, createDraft18Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft18Codec as D, createStreamDecoder as a, createDraft18Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-C_xxsbKy.d.cts → codec-DHzKAUCa.d.cts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.cjs';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
-import { D as Draft13Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft13DataStream } from './types-CXlSn0I9.cjs';
+import { D as Draft13Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft13DataStream } from './types-DjxexghA.cjs';
 
 /**
  * Encode a draft-13 control message.
@@ -25,5 +26,23 @@ interface Draft13Codec extends BaseCodec<Draft13Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft13Message>;
 }
 declare function createDraft13Codec(): Draft13Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-13 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft13Codec as D, createStreamDecoder as a, createDraft13Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft13Codec as D, createStreamDecoder as a, createDraft13Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec--CVeqGQv.d.ts → codec-DdVBtvx7.d.ts}

@@ -1,3 +1,4 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.js';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
 import { D as Draft10Message, S as SubgroupStream, c as DatagramObject, d as DatagramStatusObject, F as FetchStream, b as Draft10DataStream } from './types-0IWbU9Z_.js';
 
@@ -19,5 +20,23 @@ interface Draft10Codec extends BaseCodec<Draft10Message> {
     createStreamDecoder(): TransformStream<Uint8Array, Draft10Message>;
 }
 declare function createDraft10Codec(): Draft10Codec;
+/**
+ * Overwrite every AUTHORIZATION_INFO value in a draft-10 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the credentials were so the caller never has to
+ * hold a frame that contains one. A caller that also wants the message should
+ * decode the **redacted** frame with {@link decodeMessage}, which then cannot
+ * produce a value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft10Codec as D, createStreamDecoder as a, createDraft10Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft10Codec as D, createStreamDecoder as a, createDraft10Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-CviAa4lp.d.ts → codec-DlxGuYMv.d.ts}

@@ -1,5 +1,6 @@
+import { A as AuthRedaction } from './auth-redaction-DsdLq4Qs.js';
 import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
-import { D as Draft19Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft19DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-zHgCS6o5.js';
+import { D as Draft19Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft19DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-Btp416jt.js';
 
 /**
  * Encode a draft-18 control message with type(varint) + length(uint16 BE) + payload.
@@ -26,5 +27,23 @@ interface Draft19Codec extends BaseCodec<Draft19Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft19Codec(): Draft19Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-19 control frame.
+ *
+ * One decode, whose *output is discarded*: the point is not to read the
+ * message, it is to learn where the tokens were so the caller never has to hold
+ * a frame that contains one. A caller that also wants the message should decode
+ * the **redacted** frame with {@link decodeMessage}, which then cannot produce a
+ * token value because there is no longer one in the bytes.
+ *
+ * A frame that fails to decode is still redacted as far as the decode got. That
+ * is the useful direction to fail in: a value that was read is a value that was
+ * exposed, whatever went wrong after it.
+ *
+ * See {@link AuthRedaction.incomplete} for the one result a caller must not
+ * treat as clean, and {@link AuthRedaction.decoded} for the residual it cannot
+ * close.
+ */
+declare function redactAuthTokens(bytes: Uint8Array): AuthRedaction;
 
-export { type Draft19Codec as D, createStreamDecoder as a, createDraft19Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft19Codec as D, createStreamDecoder as a, createDraft19Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };