(AI) Initial moq-transport-15 support

AGENTS.md

@@ -0,0 +1 @@
+CLAUDE.md

CLAUDE.md

@@ -1,6 +1,6 @@
 # CLAUDE.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+This file provides guidance for AI coding agents when working with code in this repository.
 
 ## Project Overview
 
@@ -14,7 +14,7 @@ just fix          # Auto-fix linting issues
 just build        # Build all packages
 ```
 
-Except when being run in the Claude Code on the web: Use cargo/bun directly.
+If `just` is unavailable, use `cargo` or `bun` directly.
 
 ## Architecture
 

Cargo.toml

@@ -26,8 +26,8 @@ web-async = { version = "0.1.1", features = ["tracing"] }
 web-transport-iroh = "0.1.1"
 web-transport-quiche = "0.2"
 web-transport-quinn = "0.11"
-web-transport-trait = "0.3"
-web-transport-ws = "0.2"
+web-transport-trait = "0.3.2"
+web-transport-ws = "0.2.2"
 
 [profile.dev]
 panic = "abort"

js/lite/src/connection/connect.ts

@@ -57,21 +57,34 @@ export async function connect(url: URL, props?: ConnectProps): Promise<Establish
 	}
 
 	// Race them, using `.any` to ignore if one participant has a error.
-	const quic = await Promise.any(
+	const session = await Promise.any(
 		webtransport ? (websocket ? [websocket, webtransport] : [webtransport]) : [websocket],
 	);
 	if (done) done();
 
-	if (!quic) throw new Error("no transport available");
+	if (!session) throw new Error("no transport available");
 
 	// Save if WebSocket won the last race, so we won't give QUIC a head start next time.
-	if (quic instanceof WebTransportWs) {
+	if (session instanceof WebTransportWs) {
 		console.warn(url.toString(), "using WebSocket fallback; the user experience may be degraded");
 		websocketWon.add(url.toString());
 	}
 
 	// moq-rs currently requires the ROLE extension to be set.
-	const stream = await Stream.open(quic);
+	const stream = await Stream.open(session);
+
+	// @ts-expect-error - TODO: add protocol to WebTransport
+	const protocol = session instanceof WebTransport ? session.protocol : undefined;
+
+	// Choose setup encoding based on negotiated WebTransport protocol (if any).
+	let setupVersion: Ietf.Version;
+	if (protocol === Ietf.ALPN.DRAFT_15) {
+		setupVersion = Ietf.Version.DRAFT_15;
+	} else if (protocol === undefined) {
+		setupVersion = Ietf.Version.DRAFT_14;
+	} else {
+		throw new Error(`unsupported WebTransport protocol: ${protocol}`);
+	}
 
 	// We're encoding 0x20 so it's backwards compatible with moq-transport-10+
 	await stream.writer.u53(Lite.StreamId.ClientCompat);
@@ -82,26 +95,34 @@ export async function connect(url: URL, props?: ConnectProps): Promise<Establish
 	params.setVarint(Ietf.Parameter.MaxRequestId, 42069n); // Allow a ton of request IDs.
 	params.setBytes(Ietf.Parameter.Implementation, encoder.encode("moq-lite-js")); // Put the implementation name in the parameters.
 
-	const client = new Ietf.ClientSetup([Lite.Version.DRAFT_02, Lite.Version.DRAFT_01, Ietf.Version.DRAFT_14], params);
+	const client = new Ietf.ClientSetup(
+		// NOTE: draft 15 onwards does not use CLIENT_SETUP to negotiate the version.
+		// We still echo it just to make sure we're not accidentally trying to negotiate the version.
+		setupVersion === Ietf.Version.DRAFT_15
+			? [Ietf.Version.DRAFT_15]
+			: [Lite.Version.DRAFT_02, Lite.Version.DRAFT_01, Ietf.Version.DRAFT_14],
+		params,
+	);
 	console.debug(url.toString(), "sending client setup", client);
-	await client.encode(stream.writer);
+	await client.encode(stream.writer, setupVersion);
 
 	// And we expect 0x21 as the response.
 	const serverCompat = await stream.reader.u53();
 	if (serverCompat !== Lite.StreamId.ServerCompat) {
 		throw new Error(`unsupported server message type: ${serverCompat.toString()}`);
 	}
 
-	const server = await Ietf.ServerSetup.decode(stream.reader);
+	// Decode ServerSetup in Draft14 format (version + params)
+	const server = await Ietf.ServerSetup.decode(stream.reader, setupVersion);
 	console.debug(url.toString(), "received server setup", server);
 
 	if (Object.values(Lite.Version).includes(server.version as Lite.Version)) {
 		console.debug(url.toString(), "moq-lite session established");
-		return new Lite.Connection(url, quic, stream, server.version as Lite.Version);
+		return new Lite.Connection(url, session, stream, server.version as Lite.Version);
 	} else if (Object.values(Ietf.Version).includes(server.version as Ietf.Version)) {
 		const maxRequestId = server.parameters.getVarint(Ietf.Parameter.MaxRequestId) ?? 0n;
-		console.debug(url.toString(), "moq-ietf session established");
-		return new Ietf.Connection(url, quic, stream, maxRequestId);
+		console.debug(url.toString(), "moq-ietf session established, version:", server.version.toString(16));
+		return new Ietf.Connection(url, session, stream, maxRequestId, server.version as Ietf.IetfVersion);
 	} else {
 		throw new Error(`unsupported server version: ${server.version.toString()}`);
 	}
@@ -117,6 +138,8 @@ async function connectWebTransport(
 	const finalOptions: WebTransportOptions = {
 		allowPooling: false,
 		congestionControl: "low-latency",
+		// @ts-expect-error - TODO: add protocols to WebTransportOptions
+		protocols: [Ietf.ALPN.DRAFT_15],
 		...options,
 	};
 
@@ -161,7 +184,7 @@ async function connectWebTransport(
 }
 
 // TODO accept arguments to control the port/path used.
-async function connectWebSocket(url: URL, delay: number, cancel: Promise<void>): Promise<WebTransport | undefined> {
+async function connectWebSocket(url: URL, delay: number, cancel: Promise<void>): Promise<WebTransportWs | undefined> {
 	const timer = new Promise<void>((resolve) => setTimeout(resolve, delay));
 
 	const active = await Promise.race([cancel, timer.then(() => true)]);

js/lite/src/ietf/connection.ts

@@ -17,7 +17,7 @@ import {
 	PublishNamespaceOk,
 } from "./publish_namespace.ts";
 import { Publisher } from "./publisher.ts";
-import { MaxRequestId, RequestsBlocked } from "./request.ts";
+import { MaxRequestId, RequestError, RequestOk, RequestsBlocked } from "./request.ts";
 import * as Setup from "./setup.ts";
 import { Subscribe, SubscribeError, SubscribeOk, Unsubscribe } from "./subscribe.ts";
 import {
@@ -28,6 +28,7 @@ import {
 } from "./subscribe_namespace.ts";
 import { Subscriber } from "./subscriber.ts";
 import { TrackStatus, TrackStatusRequest } from "./track.ts";
+import type { IetfVersion } from "./version.ts";
 
 /**
  * Represents a connection to a MoQ server using moq-transport protocol.
@@ -58,13 +59,15 @@ export class Connection implements Established {
 	 * @param url - The URL of the connection
 	 * @param quic - The WebTransport session
 	 * @param controlStream - The control stream
+	 * @param maxRequestId - The initial max request ID
+	 * @param version - The negotiated protocol version
 	 *
 	 * @internal
 	 */
-	constructor(url: URL, quic: WebTransport, control: Stream, maxRequestId: bigint) {
+	constructor(url: URL, quic: WebTransport, control: Stream, maxRequestId: bigint, version?: IetfVersion) {
 		this.url = url;
 		this.#quic = quic;
-		this.#control = new Control.Stream(control, maxRequestId);
+		this.#control = new Control.Stream(control, maxRequestId, version);
 
 		this.#quic.closed.finally(() => {
 			this.#control.close();
@@ -203,6 +206,14 @@ export class Connection implements Established {
 					this.#control.maxRequestId(msg.requestId);
 				} else if (msg instanceof RequestsBlocked) {
 					console.warn("ignoring REQUESTS_BLOCKED message");
+				} else if (msg instanceof RequestOk) {
+					// v15: Route RequestOk to both publisher and subscriber
+					await this.#publisher.handleRequestOk(msg);
+					await this.#subscriber.handleRequestOk(msg);
+				} else if (msg instanceof RequestError) {
+					// v15: Route RequestError to both publisher and subscriber
+					await this.#publisher.handleRequestError(msg);
+					await this.#subscriber.handleRequestError(msg);
 				} else {
 					unreachable(msg);
 				}

js/lite/src/ietf/control.ts

@@ -1,5 +1,5 @@
 import { Mutex } from "async-mutex";
-import type { Stream as StreamInner } from "../stream.ts";
+import type { Reader, Stream as StreamInner, Writer } from "../stream.ts";
 import { Fetch, FetchCancel, FetchError, FetchOk } from "./fetch.ts";
 import { GoAway } from "./goaway.ts";
 import { Publish, PublishDone, PublishError, PublishOk } from "./publish.ts";
@@ -10,7 +10,7 @@ import {
 	PublishNamespaceError,
 	PublishNamespaceOk,
 } from "./publish_namespace.ts";
-import { MaxRequestId, RequestsBlocked } from "./request.ts";
+import { MaxRequestId, RequestError, RequestOk, RequestsBlocked } from "./request.ts";
 import * as Setup from "./setup.ts";
 import { Subscribe, SubscribeError, SubscribeOk, Unsubscribe } from "./subscribe.ts";
 import {
@@ -20,11 +20,10 @@ import {
 	UnsubscribeNamespace,
 } from "./subscribe_namespace.ts";
 import { TrackStatus, TrackStatusRequest } from "./track.ts";
+import { type IetfVersion, Version } from "./version.ts";
 
-/**
- * Control message types as defined in moq-transport-14
- */
-const Messages = {
+// v14 message map — IDs that have different meanings in v15 are handled specially
+const MessagesV14 = {
 	[Setup.ClientSetup.id]: Setup.ClientSetup,
 	[Setup.ServerSetup.id]: Setup.ServerSetup,
 	[Subscribe.id]: Subscribe,
@@ -55,15 +54,42 @@ const Messages = {
 	[RequestsBlocked.id]: RequestsBlocked,
 } as const;
 
-export type MessageId = keyof typeof Messages;
+// v15 message map — 0x05 → RequestError, 0x07 → RequestOk (different wire format)
+// Messages removed in v15 (0x08, 0x0E, 0x12, 0x13, 0x19, 0x1E, 0x1F) are excluded and will be rejected
+const MessagesV15 = {
+	[Setup.ClientSetup.id]: Setup.ClientSetup,
+	[Setup.ServerSetup.id]: Setup.ServerSetup,
+	[Subscribe.id]: Subscribe,
+	[SubscribeOk.id]: SubscribeOk,
+	[RequestError.id]: RequestError, // 0x05 → RequestError instead of SubscribeError
+	[PublishNamespace.id]: PublishNamespace,
+	[RequestOk.id]: RequestOk, // 0x07 → RequestOk instead of PublishNamespaceOk
+	[PublishNamespaceDone.id]: PublishNamespaceDone,
+	[Unsubscribe.id]: Unsubscribe,
+	[PublishDone.id]: PublishDone,
+	[PublishNamespaceCancel.id]: PublishNamespaceCancel,
+	[TrackStatusRequest.id]: TrackStatusRequest,
+	[GoAway.id]: GoAway,
+	[Fetch.id]: Fetch,
+	[FetchCancel.id]: FetchCancel,
+	[FetchOk.id]: FetchOk,
+	[SubscribeNamespace.id]: SubscribeNamespace,
+	[UnsubscribeNamespace.id]: UnsubscribeNamespace,
+	[Publish.id]: Publish,
+	[MaxRequestId.id]: MaxRequestId,
+	[RequestsBlocked.id]: RequestsBlocked,
+} as const;
 
-export type MessageType = (typeof Messages)[keyof typeof Messages];
+type V14MessageType = (typeof MessagesV14)[keyof typeof MessagesV14];
+type V15MessageType = (typeof MessagesV15)[keyof typeof MessagesV15];
+type MessageType = V14MessageType | V15MessageType;
 
 // Type for control message instances (not constructors)
 export type Message = InstanceType<MessageType>;
 
 export class Stream {
 	stream: StreamInner;
+	version: IetfVersion;
 
 	// The client always starts at 0.
 	#requestId = 0n;
@@ -76,8 +102,9 @@ export class Stream {
 	#writeLock = new Mutex();
 	#readLock = new Mutex();
 
-	constructor(stream: StreamInner, maxRequestId: bigint) {
+	constructor(stream: StreamInner, maxRequestId: bigint, version: IetfVersion = Version.DRAFT_14) {
 		this.stream = stream;
+		this.version = version;
 		this.#maxRequestId = maxRequestId;
 		this.#maxRequestIdPromise = new Promise((resolve) => {
 			this.#maxRequestIdResolve = resolve;
@@ -96,7 +123,8 @@ export class Stream {
 			await this.stream.writer.u53((message.constructor as MessageType).id);
 
 			// Write message payload with u16 size prefix
-			await message.encode(this.stream.writer);
+			// Extra version arg is silently ignored by messages that don't need it
+			await (message.encode as (w: Writer, v?: IetfVersion) => Promise<void>)(this.stream.writer, this.version);
 		});
 	}
 
@@ -107,12 +135,21 @@ export class Stream {
 	async read(): Promise<Message> {
 		return await this.#readLock.runExclusive(async () => {
 			const messageType = await this.stream.reader.u53();
-			if (!(messageType in Messages)) {
+
+			const messages = this.version === Version.DRAFT_15 ? MessagesV15 : MessagesV14;
+			if (!(messageType in messages)) {
 				throw new Error(`Unknown control message type: ${messageType}`);
 			}
 
 			try {
-				const msg = await Messages[messageType].decode(this.stream.reader);
+				const msgClass = messages[messageType as keyof typeof messages];
+
+				// Extra version arg is silently ignored by messages that don't need it
+				const msg = await (msgClass as { decode: (r: Reader, v?: IetfVersion) => Promise<Message> }).decode(
+					this.stream.reader,
+					this.version,
+				);
+
 				console.debug("message read", msg);
 				return msg;
 			} catch (err) {