@moqtap/trace 0.1.1 → 0.1.3

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 moqtap
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 moqtap
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -21,82 +21,82 @@ npm install @moqtap/trace @moqtap/codec
 ### Recording a session
 
 ```typescript
-import { createRecorder, writeMoqtrace } from '@moqtap/trace';
-import { createDraft14SessionState } from '@moqtap/codec/draft14/session';
+import { createRecorder, writeMoqtrace } from '@moqtap/trace'
+import { createDraft17SessionState } from '@moqtap/codec/draft17/session'
 
 const recorder = createRecorder({
-  protocol: 'moq-transport-14',
+  protocol: 'moq-transport-17',
   perspective: 'client',
   detail: 'control',
-});
+})
 
 // Wrap a session to auto-capture control messages and state transitions
-const session = createDraft14SessionState({ codec: { draft: 'draft-ietf-moq-transport-14' }, role: 'client' });
-const traced = recorder.wrapSession(session);
+const session = createDraft17SessionState('client')
+const traced = recorder.wrapSession(session)
 
 // Use `traced` instead of `session` — all send/receive calls are recorded
-traced.send(clientSetupMessage);
-traced.receive(serverSetupMessage);
+traced.send(setupMessage)
+traced.receive(setupMessage)
 
 // Manually record events the session layer doesn't see
-recorder.recordStreamOpened(4n, 0, 0); // outgoing subgroup stream
-recorder.annotate('connected', { relay: 'cdn.example.com' });
+recorder.recordStreamOpened(4n, 0, 0) // outgoing subgroup stream
+recorder.annotate('connected', { relay: 'cdn.example.com' })
 
 // Finalize and serialize
-const trace = recorder.finalize();
-const bytes = writeMoqtrace(trace); // → Uint8Array (.moqtrace binary)
+const trace = recorder.finalize()
+const bytes = writeMoqtrace(trace) // → Uint8Array (.moqtrace binary)
 ```
 
 ### Reading a trace file
 
 ```typescript
-import { readMoqtrace, readMoqtraceHeader } from '@moqtap/trace';
+import { readMoqtrace, readMoqtraceHeader } from '@moqtap/trace'
 
 // Quick metadata peek (no event parsing)
-const header = readMoqtraceHeader(bytes);
-console.log(header.protocol);   // "moq-transport-14"
-console.log(header.perspective); // "client"
-console.log(header.detail);     // "control"
+const header = readMoqtraceHeader(bytes)
+console.log(header.protocol) // "moq-transport-17"
+console.log(header.perspective) // "client"
+console.log(header.detail) // "control"
 
 // Full parse
-const trace = readMoqtrace(bytes);
+const trace = readMoqtrace(bytes)
 for (const event of trace.events) {
-  console.log(event.type, event.timestamp);
+  console.log(event.type, event.timestamp)
 }
 ```
 
 ### Streaming writer (for large traces)
 
 ```typescript
-import { createMoqtraceWriter } from '@moqtap/trace';
+import { createMoqtraceWriter } from '@moqtap/trace'
 
-const writer = createMoqtraceWriter(header);
-outputStream.write(writer.preamble());
+const writer = createMoqtraceWriter(header)
+outputStream.write(writer.preamble())
 
 for (const event of events) {
-  outputStream.write(writer.writeEvent(event));
+  outputStream.write(writer.writeEvent(event))
 }
 ```
 
 ## Detail Levels
 
-| Level | What's recorded |
-|---|---|
-| `control` | Control messages only (setup, subscribe, publish, goaway) |
-| `headers` | + data stream headers (subgroup/fetch, object metadata) |
-| `headers+sizes` | + payload byte lengths |
-| `headers+data` | + full payload bytes |
-| `full` | + raw wire bytes (pre-decode) |
+| Level           | What's recorded                                           |
+| --------------- | --------------------------------------------------------- |
+| `control`       | Control messages only (setup, subscribe, publish, goaway) |
+| `headers`       | + data stream headers (subgroup/fetch, object metadata)   |
+| `headers+sizes` | + payload byte lengths                                    |
+| `headers+data`  | + full payload bytes                                      |
+| `full`          | + raw wire bytes (pre-decode)                             |
 
 ## JSON Export
 
 For human-readable debugging (not lossless — bigint/Uint8Array become strings):
 
 ```typescript
-import { traceToJSON } from '@moqtap/trace';
+import { traceToJSON } from '@moqtap/trace'
 
-const json = traceToJSON(trace);
-console.log(json);
+const json = traceToJSON(trace)
+console.log(json)
 ```
 
 ## File Format

package/dist/index.cjs

@@ -1,5 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/binary.ts
 var _cborx = require('cbor-x');
+var codec = new (0, _cborx.Encoder)({ useRecords: false, mapsAsObjects: true });
+var encode = (value) => codec.encode(value);
+var decode = (bytes) => codec.decode(bytes);
+var decodeMultiple = (bytes, cb) => {
+  codec.decodeMultiple(bytes, cb);
+};
 var MAGIC = new Uint8Array([77, 79, 81, 84, 82, 65, 67, 69]);
 var FORMAT_VERSION = 1;
 var PREAMBLE_SIZE = 16;
@@ -230,12 +236,12 @@ function validatePreamble(bytes) {
   return { version, headerLength };
 }
 function writeMoqtrace(trace) {
-  const headerCbor = _cborx.encode.call(void 0, headerToCbor(trace.header));
+  const headerCbor = encode(headerToCbor(trace.header));
   const preamble = writePreamble(headerCbor);
   const eventChunks = [];
   let totalEventBytes = 0;
   for (const event of trace.events) {
-    const chunk = _cborx.encode.call(void 0, eventToCbor(event));
+    const chunk = encode(eventToCbor(event));
     eventChunks.push(chunk);
     totalEventBytes += chunk.length;
   }
@@ -251,11 +257,11 @@ function writeMoqtrace(trace) {
 function readMoqtrace(bytes) {
   const { headerLength } = validatePreamble(bytes);
   const headerBytes = bytes.slice(PREAMBLE_SIZE, PREAMBLE_SIZE + headerLength);
-  const header = cborToHeader(_cborx.decode.call(void 0, headerBytes));
+  const header = cborToHeader(decode(headerBytes));
   const eventBytes = bytes.slice(PREAMBLE_SIZE + headerLength);
   const events = [];
   if (eventBytes.length > 0) {
-    _cborx.decodeMultiple.call(void 0, eventBytes, (obj) => {
+    decodeMultiple(eventBytes, (obj) => {
       events.push(cborToEvent(obj));
     });
   }
@@ -264,17 +270,17 @@ function readMoqtrace(bytes) {
 function readMoqtraceHeader(bytes) {
   const { headerLength } = validatePreamble(bytes);
   const headerBytes = bytes.slice(PREAMBLE_SIZE, PREAMBLE_SIZE + headerLength);
-  return cborToHeader(_cborx.decode.call(void 0, headerBytes));
+  return cborToHeader(decode(headerBytes));
 }
 function createMoqtraceWriter(header) {
-  const headerCbor = _cborx.encode.call(void 0, headerToCbor(header));
+  const headerCbor = encode(headerToCbor(header));
   const preambleBytes = writePreamble(headerCbor);
   return {
     preamble() {
       return preambleBytes;
     },
     writeEvent(event) {
-      return _cborx.encode.call(void 0, eventToCbor(event));
+      return encode(eventToCbor(event));
     }
   };
 }

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { SessionState } from '@moqtap/codec/session';
 
-type DetailLevel = "control" | "headers" | "headers+sizes" | "headers+data" | "full";
-type Perspective = "client" | "server" | "observer";
+type DetailLevel = 'control' | 'headers' | 'headers+sizes' | 'headers+data' | 'full';
+type Perspective = 'client' | 'server' | 'observer';
 interface TraceHeader {
     readonly protocol: string;
     readonly perspective: Perspective;
@@ -19,25 +19,25 @@ interface BaseEvent {
     readonly timestamp: number;
 }
 interface ControlMessageEvent extends BaseEvent {
-    readonly type: "control";
+    readonly type: 'control';
     readonly direction: 0 | 1;
     readonly messageType: number;
     readonly message: Record<string, unknown>;
     readonly raw?: Uint8Array;
 }
 interface StreamOpenedEvent extends BaseEvent {
-    readonly type: "stream-opened";
+    readonly type: 'stream-opened';
     readonly streamId: bigint;
     readonly direction: 0 | 1;
     readonly streamType: 0 | 1 | 2;
 }
 interface StreamClosedEvent extends BaseEvent {
-    readonly type: "stream-closed";
+    readonly type: 'stream-closed';
     readonly streamId: bigint;
     readonly errorCode: number;
 }
 interface ObjectHeaderEvent extends BaseEvent {
-    readonly type: "object-header";
+    readonly type: 'object-header';
     readonly streamId: bigint;
     readonly groupId: bigint;
     readonly objectId: bigint;
@@ -45,7 +45,7 @@ interface ObjectHeaderEvent extends BaseEvent {
     readonly objectStatus: number;
 }
 interface ObjectPayloadEvent extends BaseEvent {
-    readonly type: "object-payload";
+    readonly type: 'object-payload';
     readonly streamId: bigint;
     readonly groupId: bigint;
     readonly objectId: bigint;
@@ -53,17 +53,17 @@ interface ObjectPayloadEvent extends BaseEvent {
     readonly payload?: Uint8Array;
 }
 interface StateChangeEvent extends BaseEvent {
-    readonly type: "state-change";
+    readonly type: 'state-change';
     readonly from: string;
     readonly to: string;
 }
 interface TraceErrorEvent extends BaseEvent {
-    readonly type: "error";
+    readonly type: 'error';
     readonly errorCode: number;
     readonly reason: string;
 }
 interface AnnotationEvent extends BaseEvent {
-    readonly type: "annotation";
+    readonly type: 'annotation';
     readonly label: string;
     readonly data: unknown;
 }
@@ -121,7 +121,9 @@ declare function traceToJSON(trace: Trace): string;
 
 interface TraceRecorder {
     /** Wrap a SessionState to auto-record control messages and state changes. */
-    wrapSession(session: SessionState): SessionState;
+    wrapSession<M extends {
+        type: string;
+    }, T extends string>(session: SessionState<M, T>): SessionState<M, T>;
     /** Record an arbitrary event manually. */
     record(event: TraceEvent): void;
     /** Record a stream-opened event. Ignored at 'control' detail level. */

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { SessionState } from '@moqtap/codec/session';
 
-type DetailLevel = "control" | "headers" | "headers+sizes" | "headers+data" | "full";
-type Perspective = "client" | "server" | "observer";
+type DetailLevel = 'control' | 'headers' | 'headers+sizes' | 'headers+data' | 'full';
+type Perspective = 'client' | 'server' | 'observer';
 interface TraceHeader {
     readonly protocol: string;
     readonly perspective: Perspective;
@@ -19,25 +19,25 @@ interface BaseEvent {
     readonly timestamp: number;
 }
 interface ControlMessageEvent extends BaseEvent {
-    readonly type: "control";
+    readonly type: 'control';
     readonly direction: 0 | 1;
     readonly messageType: number;
     readonly message: Record<string, unknown>;
     readonly raw?: Uint8Array;
 }
 interface StreamOpenedEvent extends BaseEvent {
-    readonly type: "stream-opened";
+    readonly type: 'stream-opened';
     readonly streamId: bigint;
     readonly direction: 0 | 1;
     readonly streamType: 0 | 1 | 2;
 }
 interface StreamClosedEvent extends BaseEvent {
-    readonly type: "stream-closed";
+    readonly type: 'stream-closed';
     readonly streamId: bigint;
     readonly errorCode: number;
 }
 interface ObjectHeaderEvent extends BaseEvent {
-    readonly type: "object-header";
+    readonly type: 'object-header';
     readonly streamId: bigint;
     readonly groupId: bigint;
     readonly objectId: bigint;
@@ -45,7 +45,7 @@ interface ObjectHeaderEvent extends BaseEvent {
     readonly objectStatus: number;
 }
 interface ObjectPayloadEvent extends BaseEvent {
-    readonly type: "object-payload";
+    readonly type: 'object-payload';
     readonly streamId: bigint;
     readonly groupId: bigint;
     readonly objectId: bigint;
@@ -53,17 +53,17 @@ interface ObjectPayloadEvent extends BaseEvent {
     readonly payload?: Uint8Array;
 }
 interface StateChangeEvent extends BaseEvent {
-    readonly type: "state-change";
+    readonly type: 'state-change';
     readonly from: string;
     readonly to: string;
 }
 interface TraceErrorEvent extends BaseEvent {
-    readonly type: "error";
+    readonly type: 'error';
     readonly errorCode: number;
     readonly reason: string;
 }
 interface AnnotationEvent extends BaseEvent {
-    readonly type: "annotation";
+    readonly type: 'annotation';
     readonly label: string;
     readonly data: unknown;
 }
@@ -121,7 +121,9 @@ declare function traceToJSON(trace: Trace): string;
 
 interface TraceRecorder {
     /** Wrap a SessionState to auto-record control messages and state changes. */
-    wrapSession(session: SessionState): SessionState;
+    wrapSession<M extends {
+        type: string;
+    }, T extends string>(session: SessionState<M, T>): SessionState<M, T>;
     /** Record an arbitrary event manually. */
     record(event: TraceEvent): void;
     /** Record a stream-opened event. Ignored at 'control' detail level. */

package/dist/index.js

@@ -1,5 +1,11 @@
 // src/binary.ts
-import { decode, decodeMultiple, encode } from "cbor-x";
+import { Encoder } from "cbor-x";
+var codec = new Encoder({ useRecords: false, mapsAsObjects: true });
+var encode = (value) => codec.encode(value);
+var decode = (bytes) => codec.decode(bytes);
+var decodeMultiple = (bytes, cb) => {
+  codec.decodeMultiple(bytes, cb);
+};
 var MAGIC = new Uint8Array([77, 79, 81, 84, 82, 65, 67, 69]);
 var FORMAT_VERSION = 1;
 var PREAMBLE_SIZE = 16;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@moqtap/trace",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "MoQT session trace format — record, serialize, and analyze .moqtrace files",
   "type": "module",
   "license": "MIT",
   "author": "moqtap",
   "repository": {
     "type": "git",
-    "url": "https://github.com/moqtap/moqtap-js.git",
+    "url": "git+https://github.com/moqtap/moqtap-js.git",
     "directory": "packages/trace"
   },
   "homepage": "https://github.com/moqtap/moqtap-js/tree/master/packages/trace",
@@ -47,7 +47,7 @@
     "test": "vitest run"
   },
   "peerDependencies": {
-    "@moqtap/codec": "^0.1.0"
+    "@moqtap/codec": "^0.3.0"
   },
   "dependencies": {
     "cbor-x": "^1.6.0"