@moqtap/codec 0.1.0

package/src/drafts/draft07/index.ts

@@ -0,0 +1,70 @@
+export { encodeVarInt, decodeVarInt } from './varint.js';
+export { createDraft07Codec } from './codec.js';
+export { encodeParameters, decodeParameters } from './parameters.js';
+export { MESSAGE_TYPE_IDS, MESSAGE_ID_TO_TYPE } from './messages.js';
+export {
+  CONTROL_MESSAGES,
+  DATA_MESSAGES,
+  CLIENT_ONLY_MESSAGES,
+  SERVER_ONLY_MESSAGES,
+  getLegalOutgoing,
+  getLegalIncoming,
+} from './rules.js';
+
+// Re-export types consumers need
+export type {
+  MoqtMessage,
+  DecodeResult,
+  DecodeErrorCode,
+  ClientSetup,
+  ServerSetup,
+  Subscribe,
+  SubscribeOk,
+  SubscribeError,
+  SubscribeDone,
+  Unsubscribe,
+  Announce,
+  AnnounceOk,
+  AnnounceError,
+  AnnounceCancel,
+  Unannounce,
+  TrackStatusRequest,
+  TrackStatus,
+  ObjectStream,
+  ObjectDatagram,
+  StreamHeaderTrack,
+  StreamHeaderGroup,
+  StreamHeaderSubgroup,
+  GoAway,
+  SubscribeAnnounces,
+  SubscribeAnnouncesOk,
+  SubscribeAnnouncesError,
+  Fetch,
+  FetchOk,
+  FetchError,
+  FetchCancel,
+  SubscribeUpdate,
+  UnsubscribeAnnounces,
+  MaxSubscribeId,
+  FilterType,
+  GroupOrderValue,
+  MoqtMessageType,
+} from '../../core/types.js';
+export { DecodeError } from '../../core/types.js';
+
+import { createDraft07Codec } from './codec.js';
+import type { DecodeResult, MoqtMessage } from '../../core/types.js';
+
+const defaultCodec = createDraft07Codec();
+
+export function encodeMessage(message: MoqtMessage): Uint8Array {
+  return defaultCodec.encodeMessage(message);
+}
+
+export function decodeMessage(bytes: Uint8Array): DecodeResult<MoqtMessage> {
+  return defaultCodec.decodeMessage(bytes);
+}
+
+export function createStreamDecoder(): TransformStream<Uint8Array, MoqtMessage> {
+  return defaultCodec.createStreamDecoder();
+}

package/src/drafts/draft07/messages.ts

@@ -0,0 +1,44 @@
+// MoQT draft-ietf-moq-transport-07 message type IDs (wire format)
+export const MESSAGE_TYPE_IDS = {
+  // Control messages (on control stream)
+  subscribe_update: 0x02n,
+  subscribe: 0x03n,
+  subscribe_ok: 0x04n,
+  subscribe_error: 0x05n,
+  announce: 0x06n,
+  announce_ok: 0x07n,
+  announce_error: 0x08n,
+  unannounce: 0x09n,
+  unsubscribe: 0x0an,
+  subscribe_done: 0x0bn,
+  announce_cancel: 0x0cn,
+  track_status_request: 0x0dn,
+  track_status: 0x0en,
+  goaway: 0x10n,
+  subscribe_announces: 0x11n,
+  subscribe_announces_ok: 0x12n,
+  subscribe_announces_error: 0x13n,
+  unsubscribe_announces: 0x14n,
+  max_subscribe_id: 0x15n,
+  fetch: 0x16n,
+  fetch_cancel: 0x17n,
+  fetch_ok: 0x18n,
+  fetch_error: 0x19n,
+  client_setup: 0x40n,
+  server_setup: 0x41n,
+  // Data stream messages
+  object_stream: 0x00n,
+  object_datagram: 0x01n,
+  stream_header_track: 0x50n,
+  stream_header_group: 0x51n,
+  stream_header_subgroup: 0x04n, // Note: same ID as subscribe_ok but used on data streams, context disambiguates
+} as const;
+
+// Reverse map: wire ID -> message type name
+export const MESSAGE_ID_TO_TYPE = new Map<bigint, string>();
+for (const [name, id] of Object.entries(MESSAGE_TYPE_IDS)) {
+  // For duplicate IDs, control stream messages take priority in the reverse map
+  if (!MESSAGE_ID_TO_TYPE.has(id) || name !== 'stream_header_subgroup') {
+    MESSAGE_ID_TO_TYPE.set(id, name);
+  }
+}

package/src/drafts/draft07/parameters.ts

@@ -0,0 +1,12 @@
+import { BufferReader } from '../../core/buffer-reader.js';
+import { BufferWriter } from '../../core/buffer-writer.js';
+
+export function encodeParameters(params: Map<bigint, Uint8Array>): Uint8Array {
+  const writer = new BufferWriter();
+  writer.writeParameters(params);
+  return writer.finish();
+}
+
+export function decodeParameters(reader: BufferReader): Map<bigint, Uint8Array> {
+  return reader.readParameters();
+}

package/src/drafts/draft07/rules.ts

@@ -0,0 +1,75 @@
+import type { MoqtMessageType } from '../../core/types.js';
+
+export const CONTROL_MESSAGES: ReadonlySet<MoqtMessageType> = new Set([
+  'client_setup', 'server_setup',
+  'subscribe', 'subscribe_ok', 'subscribe_error', 'subscribe_done', 'subscribe_update', 'unsubscribe',
+  'announce', 'announce_ok', 'announce_error', 'announce_cancel', 'unannounce',
+  'track_status_request', 'track_status',
+  'goaway',
+  'subscribe_announces', 'subscribe_announces_ok', 'subscribe_announces_error', 'unsubscribe_announces',
+  'max_subscribe_id',
+  'fetch', 'fetch_ok', 'fetch_error', 'fetch_cancel',
+]);
+
+export const DATA_MESSAGES: ReadonlySet<MoqtMessageType> = new Set([
+  'object_stream', 'object_datagram',
+  'stream_header_track', 'stream_header_group', 'stream_header_subgroup',
+]);
+
+// Messages that only a client can send
+export const CLIENT_ONLY_MESSAGES: ReadonlySet<MoqtMessageType> = new Set([
+  'client_setup',
+  'subscribe', 'subscribe_update', 'unsubscribe',
+  'announce', 'unannounce',
+  'subscribe_announces', 'unsubscribe_announces',
+  'max_subscribe_id',
+  'fetch', 'fetch_cancel',
+  'track_status_request',
+]);
+
+// Messages that only a server can send
+export const SERVER_ONLY_MESSAGES: ReadonlySet<MoqtMessageType> = new Set([
+  'server_setup',
+  'subscribe_ok', 'subscribe_error', 'subscribe_done',
+  'announce_ok', 'announce_error', 'announce_cancel',
+  'subscribe_announces_ok', 'subscribe_announces_error',
+  'max_subscribe_id',
+  'fetch_ok', 'fetch_error',
+  'track_status',
+]);
+
+// Messages legal in each session phase -- for outbound validation
+export function getLegalOutgoing(phase: string, role: 'client' | 'server'): Set<MoqtMessageType> {
+  const legal = new Set<MoqtMessageType>();
+
+  switch (phase) {
+    case 'idle':
+      if (role === 'client') legal.add('client_setup');
+      break;
+    case 'setup':
+      if (role === 'server') legal.add('server_setup');
+      break;
+    case 'ready': {
+      // Both roles can send goaway
+      legal.add('goaway');
+      const roleMessages = role === 'client' ? CLIENT_ONLY_MESSAGES : SERVER_ONLY_MESSAGES;
+      for (const msg of roleMessages) {
+        if (msg !== 'client_setup' && msg !== 'server_setup') {
+          legal.add(msg);
+        }
+      }
+      break;
+    }
+    case 'draining':
+      // Limited set during draining - can still finish active operations
+      break;
+  }
+
+  return legal;
+}
+
+export function getLegalIncoming(phase: string, role: 'client' | 'server'): Set<MoqtMessageType> {
+  // Incoming from remote = the other role's outgoing
+  const remoteRole = role === 'client' ? 'server' : 'client';
+  return getLegalOutgoing(phase, remoteRole);
+}

package/src/drafts/draft07/session-fsm.ts

@@ -0,0 +1,353 @@
+import type { MoqtMessage, MoqtMessageType } from '../../core/types.js';
+import type {
+  SessionPhase,
+  TransitionResult,
+  ValidationResult,
+  ProtocolViolation,
+  SideEffect,
+  SubscriptionState,
+  AnnounceState,
+} from '../../core/session-types.js';
+import { getLegalOutgoing, getLegalIncoming, CLIENT_ONLY_MESSAGES, SERVER_ONLY_MESSAGES } from './rules.js';
+
+function violation(code: ProtocolViolation['code'], message: string, currentPhase: SessionPhase, offendingMessage: MoqtMessageType): ProtocolViolation {
+  return { code, message, currentPhase, offendingMessage };
+}
+
+export class SessionFSM {
+  private _phase: SessionPhase = 'idle';
+  private _role: 'client' | 'server';
+  private _subscriptions = new Map<bigint, SubscriptionState>();
+  private _announces = new Map<string, AnnounceState>();
+
+  constructor(role: 'client' | 'server') {
+    this._role = role;
+  }
+
+  get phase(): SessionPhase { return this._phase; }
+  get role(): 'client' | 'server' { return this._role; }
+  get subscriptions(): ReadonlyMap<bigint, SubscriptionState> { return this._subscriptions; }
+  get announces(): ReadonlyMap<string, AnnounceState> { return this._announces; }
+
+  get legalOutgoing(): ReadonlySet<MoqtMessageType> {
+    return getLegalOutgoing(this._phase, this._role);
+  }
+
+  get legalIncoming(): ReadonlySet<MoqtMessageType> {
+    return getLegalIncoming(this._phase, this._role);
+  }
+
+  // Validate role constraints
+  private checkRole(message: MoqtMessage, direction: 'inbound' | 'outbound'): ProtocolViolation | null {
+    const senderRole = direction === 'outbound' ? this._role : (this._role === 'client' ? 'server' : 'client');
+
+    if (CLIENT_ONLY_MESSAGES.has(message.type) && senderRole !== 'client') {
+      return violation('ROLE_VIOLATION', `${message.type} can only be sent by client`, this._phase, message.type);
+    }
+    if (SERVER_ONLY_MESSAGES.has(message.type) && senderRole !== 'server') {
+      return violation('ROLE_VIOLATION', `${message.type} can only be sent by server`, this._phase, message.type);
+    }
+    return null;
+  }
+
+  validateOutgoing(message: MoqtMessage): ValidationResult {
+    const roleViolation = this.checkRole(message, 'outbound');
+    if (roleViolation) return { ok: false, violation: roleViolation };
+
+    if (!this.legalOutgoing.has(message.type)) {
+      return {
+        ok: false,
+        violation: violation(
+          this._phase === 'idle' || this._phase === 'setup' ? 'MESSAGE_BEFORE_SETUP' : 'UNEXPECTED_MESSAGE',
+          `Cannot send ${message.type} in phase ${this._phase}`,
+          this._phase,
+          message.type,
+        ),
+      };
+    }
+    return { ok: true };
+  }
+
+  receive(message: MoqtMessage): TransitionResult {
+    const roleViolation = this.checkRole(message, 'inbound');
+    if (roleViolation) return { ok: false, violation: roleViolation };
+
+    return this.applyTransition(message, 'inbound');
+  }
+
+  send(message: MoqtMessage): TransitionResult {
+    const roleViolation = this.checkRole(message, 'outbound');
+    if (roleViolation) return { ok: false, violation: roleViolation };
+
+    return this.applyTransition(message, 'outbound');
+  }
+
+  private applyTransition(message: MoqtMessage, direction: 'inbound' | 'outbound'): TransitionResult {
+    const sideEffects: SideEffect[] = [];
+
+    switch (message.type) {
+      case 'client_setup':
+        return this.handleClientSetup(message, direction);
+      case 'server_setup':
+        return this.handleServerSetup(message, direction);
+      case 'goaway':
+        return this.handleGoAway(message, direction, sideEffects);
+
+      // Subscription lifecycle
+      case 'subscribe':
+        return this.handleSubscribe(message, direction, sideEffects);
+      case 'subscribe_ok':
+        return this.handleSubscribeOk(message, direction, sideEffects);
+      case 'subscribe_error':
+        return this.handleSubscribeError(message, direction, sideEffects);
+      case 'subscribe_done':
+        return this.handleSubscribeDone(message, direction, sideEffects);
+      case 'unsubscribe':
+        return this.handleUnsubscribe(message, direction, sideEffects);
+
+      // Announce lifecycle
+      case 'announce':
+        return this.handleAnnounce(message, direction, sideEffects);
+      case 'announce_ok':
+        return this.handleAnnounceOk(message, direction, sideEffects);
+      case 'announce_error':
+        return this.handleAnnounceError(message, direction, sideEffects);
+      case 'announce_cancel':
+        return this.handleAnnounceCancel(message, direction, sideEffects);
+      case 'unannounce':
+        return this.handleUnannounce(message, direction, sideEffects);
+
+      // Fetch lifecycle
+      case 'fetch':
+      case 'fetch_ok':
+      case 'fetch_error':
+      case 'fetch_cancel':
+        return this.handleReadyPhaseMessage(message);
+
+      // Other ready-phase messages
+      default:
+        return this.handleReadyPhaseMessage(message);
+    }
+  }
+
+  private handleClientSetup(_message: MoqtMessage, direction: 'inbound' | 'outbound'): TransitionResult {
+    if (this._phase !== 'idle') {
+      return { ok: false, violation: violation('SETUP_VIOLATION', 'CLIENT_SETUP already sent/received', this._phase, 'client_setup') };
+    }
+
+    if (direction === 'outbound' && this._role !== 'client') {
+      return { ok: false, violation: violation('ROLE_VIOLATION', 'Only client can send CLIENT_SETUP', this._phase, 'client_setup') };
+    }
+
+    this._phase = 'setup';
+    return { ok: true, phase: this._phase, sideEffects: [] };
+  }
+
+  private handleServerSetup(_message: MoqtMessage, direction: 'inbound' | 'outbound'): TransitionResult {
+    if (this._phase !== 'setup') {
+      return { ok: false, violation: violation('SETUP_VIOLATION', 'SERVER_SETUP before CLIENT_SETUP', this._phase, 'server_setup') };
+    }
+
+    if (direction === 'outbound' && this._role !== 'server') {
+      return { ok: false, violation: violation('ROLE_VIOLATION', 'Only server can send SERVER_SETUP', this._phase, 'server_setup') };
+    }
+
+    this._phase = 'ready';
+    return { ok: true, phase: this._phase, sideEffects: [{ type: 'session-ready' }] };
+  }
+
+  private handleGoAway(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    if (this._phase !== 'ready' && this._phase !== 'draining') {
+      return { ok: false, violation: violation('UNEXPECTED_MESSAGE', `GOAWAY not valid in phase ${this._phase}`, this._phase, 'goaway') };
+    }
+    this._phase = 'draining';
+    const goaway = message as import('../../core/types.js').GoAway;
+    sideEffects.push({ type: 'session-draining', goAwayUri: goaway.newSessionUri });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private requireReady(msgType: MoqtMessageType): ProtocolViolation | null {
+    if (this._phase !== 'ready' && this._phase !== 'draining') {
+      return violation(
+        this._phase === 'idle' || this._phase === 'setup' ? 'MESSAGE_BEFORE_SETUP' : 'UNEXPECTED_MESSAGE',
+        `${msgType} requires ready phase, current: ${this._phase}`,
+        this._phase,
+        msgType,
+      );
+    }
+    return null;
+  }
+
+  private handleSubscribe(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const sub = message as import('../../core/types.js').Subscribe;
+    if (this._subscriptions.has(sub.subscribeId)) {
+      return { ok: false, violation: violation('DUPLICATE_SUBSCRIBE_ID', `Subscribe ID ${sub.subscribeId} already exists`, this._phase, message.type) };
+    }
+
+    this._subscriptions.set(sub.subscribeId, {
+      subscribeId: sub.subscribeId,
+      phase: 'pending',
+      trackNamespace: sub.trackNamespace,
+      trackName: sub.trackName,
+    });
+
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleSubscribeOk(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const ok = message as import('../../core/types.js').SubscribeOk;
+    const existing = this._subscriptions.get(ok.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation('UNKNOWN_SUBSCRIBE_ID', `No subscription with ID ${ok.subscribeId}`, this._phase, message.type) };
+    }
+    if (existing.phase !== 'pending') {
+      return { ok: false, violation: violation('STATE_VIOLATION', `Subscription ${ok.subscribeId} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+
+    this._subscriptions.set(ok.subscribeId, { ...existing, phase: 'active' });
+    sideEffects.push({ type: 'subscription-activated', subscribeId: ok.subscribeId });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleSubscribeError(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const subErr = message as import('../../core/types.js').SubscribeError;
+    const existing = this._subscriptions.get(subErr.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation('UNKNOWN_SUBSCRIBE_ID', `No subscription with ID ${subErr.subscribeId}`, this._phase, message.type) };
+    }
+    if (existing.phase !== 'pending') {
+      return { ok: false, violation: violation('STATE_VIOLATION', `Subscription ${subErr.subscribeId} is ${existing.phase}, not pending`, this._phase, message.type) };
+    }
+
+    this._subscriptions.set(subErr.subscribeId, { ...existing, phase: 'error' });
+    sideEffects.push({ type: 'subscription-ended', subscribeId: subErr.subscribeId, reason: subErr.reasonPhrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleSubscribeDone(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const done = message as import('../../core/types.js').SubscribeDone;
+    const existing = this._subscriptions.get(done.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation('UNKNOWN_SUBSCRIBE_ID', `No subscription with ID ${done.subscribeId}`, this._phase, message.type) };
+    }
+
+    this._subscriptions.set(done.subscribeId, { ...existing, phase: 'done' });
+    sideEffects.push({ type: 'subscription-ended', subscribeId: done.subscribeId, reason: done.reasonPhrase });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleUnsubscribe(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const unsub = message as import('../../core/types.js').Unsubscribe;
+    const existing = this._subscriptions.get(unsub.subscribeId);
+    if (!existing) {
+      return { ok: false, violation: violation('UNKNOWN_SUBSCRIBE_ID', `No subscription with ID ${unsub.subscribeId}`, this._phase, message.type) };
+    }
+
+    this._subscriptions.set(unsub.subscribeId, { ...existing, phase: 'done' });
+    sideEffects.push({ type: 'subscription-ended', subscribeId: unsub.subscribeId, reason: 'unsubscribed' });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  // Announce handlers
+  private namespaceKey(ns: string[]): string {
+    return ns.join('/');
+  }
+
+  private handleAnnounce(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const ann = message as import('../../core/types.js').Announce;
+    const key = this.namespaceKey(ann.trackNamespace);
+
+    this._announces.set(key, { namespace: ann.trackNamespace, phase: 'pending' });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleAnnounceOk(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const ok = message as import('../../core/types.js').AnnounceOk;
+    const key = this.namespaceKey(ok.trackNamespace);
+    const existing = this._announces.get(key);
+    if (!existing) {
+      return { ok: false, violation: violation('UNEXPECTED_MESSAGE', `No announce for namespace ${key}`, this._phase, message.type) };
+    }
+
+    this._announces.set(key, { ...existing, phase: 'active' });
+    sideEffects.push({ type: 'announce-activated', namespace: ok.trackNamespace });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleAnnounceError(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const annErr = message as import('../../core/types.js').AnnounceError;
+    const key = this.namespaceKey(annErr.trackNamespace);
+    const existing = this._announces.get(key);
+    if (!existing) {
+      return { ok: false, violation: violation('UNEXPECTED_MESSAGE', `No announce for namespace ${key}`, this._phase, message.type) };
+    }
+
+    this._announces.set(key, { ...existing, phase: 'error' });
+    sideEffects.push({ type: 'announce-ended', namespace: annErr.trackNamespace });
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleAnnounceCancel(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const cancel = message as import('../../core/types.js').AnnounceCancel;
+    const key = this.namespaceKey(cancel.trackNamespace);
+    const existing = this._announces.get(key);
+    if (existing) {
+      this._announces.delete(key);
+      sideEffects.push({ type: 'announce-ended', namespace: cancel.trackNamespace });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleUnannounce(message: MoqtMessage, _direction: 'inbound' | 'outbound', sideEffects: SideEffect[]): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+
+    const unann = message as import('../../core/types.js').Unannounce;
+    const key = this.namespaceKey(unann.trackNamespace);
+    const existing = this._announces.get(key);
+    if (existing) {
+      this._announces.delete(key);
+      sideEffects.push({ type: 'announce-ended', namespace: unann.trackNamespace });
+    }
+    return { ok: true, phase: this._phase, sideEffects };
+  }
+
+  private handleReadyPhaseMessage(message: MoqtMessage): TransitionResult {
+    const err = this.requireReady(message.type);
+    if (err) return { ok: false, violation: err };
+    return { ok: true, phase: this._phase, sideEffects: [] };
+  }
+
+  reset(): void {
+    this._phase = 'idle';
+    this._subscriptions.clear();
+    this._announces.clear();
+  }
+}

package/src/drafts/draft07/session.ts

@@ -0,0 +1,21 @@
+import type { SessionState, SessionStateOptions } from '../../core/session-types.js';
+import { SessionFSM } from './session-fsm.js';
+
+export function createDraft07SessionState(options: SessionStateOptions): SessionState {
+  return new SessionFSM(options.role);
+}
+
+export type {
+  SessionState,
+  SessionStateOptions,
+  SessionPhase,
+  SubscriptionState,
+  SubscriptionPhase,
+  AnnounceState,
+  AnnouncePhase,
+  TransitionResult,
+  ValidationResult,
+  ProtocolViolation,
+  ProtocolViolationCode,
+  SideEffect,
+} from '../../core/session-types.js';

package/src/drafts/draft07/subscription-fsm.ts

@@ -0,0 +1,3 @@
+// Subscription state tracking is integrated into SessionFSM.
+// This file exists for the directory structure; re-exports relevant types.
+export type { SubscriptionState, SubscriptionPhase } from '../../core/session-types.js';

package/src/drafts/draft07/varint.ts

@@ -0,0 +1,23 @@
+import { BufferReader } from '../../core/buffer-reader.js';
+import { BufferWriter } from '../../core/buffer-writer.js';
+import { DecodeError } from '../../core/types.js';
+import type { DecodeResult } from '../../core/types.js';
+
+export function encodeVarInt(value: number | bigint): Uint8Array {
+  const writer = new BufferWriter(8);
+  writer.writeVarInt(value);
+  return writer.finish();
+}
+
+export function decodeVarInt(bytes: Uint8Array, offset = 0): DecodeResult<bigint> {
+  try {
+    const reader = new BufferReader(bytes, offset);
+    const value = reader.readVarInt();
+    return { ok: true, value, bytesRead: reader.offset - offset };
+  } catch (e) {
+    if (e instanceof DecodeError) {
+      return { ok: false, error: e };
+    }
+    throw e;
+  }
+}