@moqtap/codec 0.10.0 → 0.12.0

package/dist/codec-Cb8mUre3.d.ts

@@ -0,0 +1,68 @@
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.js';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.js';
+import { D as Draft21Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft21DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-DDwidj2d.js';
+
+/**
+ * `PUBLISH_DONE.Stream Count` "unknown" sentinel — draft-21 Section 9.9.
+ *
+ * draft-19 used `2^62 - 1`; draft-20 raised it to `2^64 - 1`. Both are
+ * encodable because MOQT's vi64 (Section 8.1) is a leading-ones-length
+ * prefix reaching a full 64 bits in nine bytes — it is NOT the QUIC varint and
+ * has no `2^62 - 1` ceiling. On the wire this is `ff` followed by eight `ff`
+ * bytes.
+ *
+ * JS `bigint` is required: `2^64 - 1` does not fit a `number`, and comparing a
+ * `Number(stream_count)` against this sentinel would be wrong for every value
+ * above `2^53`.
+ *
+ * Note (SPEC-DELTA Section 11 Q14): unlike the old `2^62 - 1` marker, this
+ * value is also a well-formed exact count. There is no longer any headroom
+ * that separates "unknown" from "absurdly many streams"; the draft does not
+ * acknowledge the collision.
+ */
+declare const UNKNOWN_STREAM_COUNT = 18446744073709551615n;
+/**
+ * Encode a draft-21 control message: type (vi64) + length (uint16 BE) + payload.
+ */
+declare function encodeMessage(message: Draft21Message): Uint8Array;
+/**
+ * Decode a draft-21 control message from bytes (type + uint16 length + payload).
+ */
+declare function decodeMessage(bytes: Uint8Array): DecodeResult<Draft21Message>;
+
+declare function createStreamDecoder(): TransformStream<Uint8Array, Draft21Message>;
+interface Draft21Codec extends BaseCodec<Draft21Message> {
+    readonly draft: '21';
+    encodeSubgroupStream(stream: SubgroupStream): Uint8Array;
+    encodeDatagram(dg: DatagramObject): Uint8Array;
+    encodeFetchStream(stream: FetchStream): Uint8Array;
+    decodeSubgroupStream(bytes: Uint8Array): DecodeResult<SubgroupStream>;
+    decodeDatagram(bytes: Uint8Array): DecodeResult<DatagramObject>;
+    decodeFetchStream(bytes: Uint8Array): DecodeResult<FetchStream>;
+    decodeDataStream(streamType: 'subgroup' | 'datagram' | 'fetch', bytes: Uint8Array): DecodeResult<Draft21DataStream>;
+    createStreamDecoder(): TransformStream<Uint8Array, Draft21Message>;
+    createSubgroupStreamDecoder(): TransformStream<Uint8Array, SubgroupStreamHeader | ObjectPayload>;
+    createFetchStreamDecoder(): TransformStream<Uint8Array, FetchStreamHeader | ObjectPayload>;
+    createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
+}
+declare function createDraft21Codec(): Draft21Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-21 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 Draft21Codec as D, UNKNOWN_STREAM_COUNT as U, createStreamDecoder as a, createDraft21Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-f7vxeVIS.d.cts → codec-CemqAQdR.d.cts}

@@ -1,5 +1,6 @@
-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-Bg86GGVZ.cjs';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.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-gl4_QEva.d.ts → codec-CxMvsVMS.d.ts}

@@ -1,4 +1,5 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.js';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.js';
 import { D as Draft12Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft12DataStream } from './types-CI_SX4Xe.js';
 
 /**
@@ -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-Bd60SGKH.d.cts → codec-DIgMVTi4.d.cts}

@@ -1,4 +1,5 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.cjs';
 import { D as Draft14Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft14DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-CmqT0jUf.cjs';
 
 /**
@@ -31,5 +32,23 @@ interface Draft14Codec extends BaseCodec<Draft14Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft14Codec(): Draft14Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-14 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 Draft14Codec as D, createStreamDecoder as a, createDraft14Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft14Codec as D, createStreamDecoder as a, createDraft14Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

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

@@ -1,4 +1,5 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.js';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.js';
 import { D as Draft10Message, S as SubgroupStream, c as DatagramObject, d as DatagramStatusObject, F as FetchStream, b as Draft10DataStream } from './types-0IWbU9Z_.js';
 
 declare function encodeMessage(message: Draft10Message): Uint8Array;
@@ -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-CWnf8mn_.d.cts → codec-D_O9zxax.d.ts}

@@ -1,5 +1,6 @@
-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-CZTzbIzQ.cjs';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.js';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.js';
+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.js';
 
 /**
  * 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-08ZOr5wI.d.ts → codec-Ddc-QxV6.d.cts}

@@ -1,5 +1,6 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
-import { D as Draft15Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft15DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-pShrs3fN.js';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.cjs';
+import { D as Draft15Message, f as SubgroupStream, d as DatagramObject, e as FetchStream, c as Draft15DataStream, S as SubgroupStreamHeader, O as ObjectPayload, F as FetchStreamHeader, b as DataStreamEvent } from './types-CuibHYcf.cjs';
 
 /**
  * Encode a draft-15 control message with type(varint) + length(uint16 BE) + payload.
@@ -30,5 +31,23 @@ interface Draft15Codec extends BaseCodec<Draft15Message> {
     createDataStreamDecoder(): TransformStream<Uint8Array, DataStreamEvent>;
 }
 declare function createDraft15Codec(): Draft15Codec;
+/**
+ * Overwrite every Authorization Token value in a draft-15 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 Draft15Codec as D, createStreamDecoder as a, createDraft15Codec as c, decodeMessage as d, encodeMessage as e };
+export { type Draft15Codec as D, createStreamDecoder as a, createDraft15Codec as c, decodeMessage as d, encodeMessage as e, redactAuthTokens as r };

package/dist/{codec-CBdOIfMY.d.ts → codec-DoojMl2z.d.cts}

@@ -1,5 +1,6 @@
-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-C1rxh-id.js';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.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-BrTi4K7r.d.cts → codec-DqdjiOQF.d.ts}

@@ -1,5 +1,6 @@
-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-C1rxh-id.cjs';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.js';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.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 };

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

@@ -1,4 +1,5 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.cjs';
 import { D as Draft09Message, S as SubgroupStream, c as DatagramObject, d as DatagramStatusObject, F as FetchStream, b as Draft09DataStream } from './types-B3g5G9KP.cjs';
 
 declare function encodeMessage(message: Draft09Message): Uint8Array;
@@ -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-Dl_QIXMz.d.ts → codec-Dt6nuejp.d.ts}

@@ -1,4 +1,5 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.js';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.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-Bux_Q40X.d.ts → codec-DuYhd8fP.d.cts}

@@ -1,5 +1,6 @@
-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-D4bmW8rY.js';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.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-Cfo_z5ET.d.cts → codec-DwNOFgPU.d.cts}

@@ -1,4 +1,5 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.cjs';
 import { D as Draft10Message, S as SubgroupStream, c as DatagramObject, d as DatagramStatusObject, F as FetchStream, b as Draft10DataStream } from './types-0IWbU9Z_.cjs';
 
 declare function encodeMessage(message: Draft10Message): Uint8Array;
@@ -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-guzqtfMk.d.cts → codec-l01BpNhF.d.cts}

@@ -1,4 +1,5 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.cjs';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.cjs';
 import { D as Draft12Message, S as SubgroupStream, c as DatagramObject, F as FetchStream, b as Draft12DataStream } from './types-CI_SX4Xe.cjs';
 
 /**
@@ -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-C3mdsGx3.d.ts → codec-psN2vB6I.d.cts}

@@ -1,5 +1,6 @@
-import { B as BaseCodec, b as DecodeResult } from './types-DG5_iKuv.js';
-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-CZTzbIzQ.js';
+import { A as AuthRedaction } from './auth-redaction-B9JJOlIY.cjs';
+import { B as BaseCodec, b as DecodeResult } from './types-2NisMA8_.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/draft07-session.d.cts

@@ -1,7 +1,7 @@
-import { k as SessionStateOptionsRole, a as SessionState } from './session-types-B9idsih-.cjs';
-export { A as AnnouncePhase, b as AnnounceState, P as ProtocolViolation, d as ProtocolViolationCode, g as SessionPhase, h as SideEffect, i as SubscriptionPhase, j as SubscriptionState, T as TransitionResult, V as ValidationResult } from './session-types-B9idsih-.cjs';
+import { k as SessionStateOptionsRole, a as SessionState } from './session-types-DZkI_qFG.cjs';
+export { A as AnnouncePhase, b as AnnounceState, P as ProtocolViolation, d as ProtocolViolationCode, g as SessionPhase, h as SideEffect, i as SubscriptionPhase, j as SubscriptionState, T as TransitionResult, V as ValidationResult } from './session-types-DZkI_qFG.cjs';
 import { D as Draft07Message, a as Draft07MessageType } from './types-Dl4IaAHR.cjs';
-import './types-DG5_iKuv.cjs';
+import './types-2NisMA8_.cjs';
 
 declare function createDraft07SessionState(role: SessionStateOptionsRole): SessionState<Draft07Message, Draft07MessageType>;
 

package/dist/draft07-session.d.ts

@@ -1,7 +1,7 @@
-import { k as SessionStateOptionsRole, a as SessionState } from './session-types-Dn7b3RZM.js';
-export { A as AnnouncePhase, b as AnnounceState, P as ProtocolViolation, d as ProtocolViolationCode, g as SessionPhase, h as SideEffect, i as SubscriptionPhase, j as SubscriptionState, T as TransitionResult, V as ValidationResult } from './session-types-Dn7b3RZM.js';
+import { k as SessionStateOptionsRole, a as SessionState } from './session-types-Cxx7W8zZ.js';
+export { A as AnnouncePhase, b as AnnounceState, P as ProtocolViolation, d as ProtocolViolationCode, g as SessionPhase, h as SideEffect, i as SubscriptionPhase, j as SubscriptionState, T as TransitionResult, V as ValidationResult } from './session-types-Cxx7W8zZ.js';
 import { D as Draft07Message, a as Draft07MessageType } from './types-Dl4IaAHR.js';
-import './types-DG5_iKuv.js';
+import './types-2NisMA8_.js';
 
 declare function createDraft07SessionState(role: SessionStateOptionsRole): SessionState<Draft07Message, Draft07MessageType>;