diff --git a/src/client/lib/signaling.ts b/src/client/lib/signaling.ts
index 328f548..c7485fb 100644
--- a/src/client/lib/signaling.ts
+++ b/src/client/lib/signaling.ts
@@ -154,11 +154,11 @@ export class SignalingClient {
     return this.setDisplayName(displayName);
   }
 
-  pauseSharing(): boolean {
+  setSharingPaused(paused: boolean): boolean {
     if (this.identity.role !== "host") {
       return false;
     }
-    this.identity.sharingPaused = true;
+    this.identity.sharingPaused = paused;
     if (!this.identity.shareGeneration) {
       return false;
     }
@@ -166,7 +166,7 @@ export class SignalingClient {
       return this.send({
         type: "set-sharing-paused",
         shareGeneration: this.identity.shareGeneration,
-        paused: true,
+        paused,
       });
     } catch {
       return false;
@@ -179,47 +179,6 @@ export class SignalingClient {
     }
   }
 
-  requestSharingResume(): boolean {
-    if (this.identity.role !== "host" || !this.identity.shareGeneration) {
-      return false;
-    }
-    try {
-      return this.send({
-        type: "request-sharing-resume",
-        shareGeneration: this.identity.shareGeneration,
-      });
-    } catch {
-      return false;
-    }
-  }
-
-  confirmSharingResumed(
-    authorization: Extract<
-      ServerMessage,
-      { type: "sharing-resume-authorized" }
-    >,
-  ): boolean {
-    if (
-      this.identity.role !== "host" ||
-      !this.identity.shareGeneration ||
-      authorization.shareGeneration !== this.identity.shareGeneration
-    ) {
-      return false;
-    }
-    let sent = false;
-    try {
-      sent = this.send({
-        type: "sharing-source-enabled",
-        shareGeneration: authorization.shareGeneration,
-        codecGeneration: authorization.codecGeneration,
-        resumeAttempt: authorization.resumeAttempt,
-      });
-    } catch {
-      sent = false;
-    }
-    return sent;
-  }
-
   sendThenStop(message: ClientMessage): void {
     if (this.stopped) {
       return;
diff --git a/src/client/media/codec-proof.ts b/src/client/media/codec-proof.ts
deleted file mode 100644
index bcb1516..0000000
--- a/src/client/media/codec-proof.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-import {
-  codecProofEvidenceSchema,
-  type ClientMessage,
-  type CodecProofBinding,
-  type ServerMessage,
-} from "../../shared/protocol";
-import type { ConnectionMetrics } from "../types";
-
-type ProofRequest = Extract<
-  ServerMessage,
-  { type: "video-codec-proof-request" }
->;
-
-export interface CodecProofRouteSample {
-  routeRevision: number;
-  binding: CodecProofBinding;
-  metrics: ConnectionMetrics | null;
-}
-
-interface DecodedBaseline {
-  sampleTimestampMs: number;
-  rtpStatsId: string;
-  rtpSsrc: number | null;
-  rtpMid: string | null;
-  rtpRid: string | null;
-  trackIdentifier: string | null;
-}
-
-interface PendingProof {
-  request: ProofRequest;
-  baseline: DecodedBaseline | null;
-}
-
-export class CodecProofReporter {
-  private pending: PendingProof | null = null;
-
-  constructor(
-    private readonly send: (message: ClientMessage) => boolean,
-  ) {}
-
-  request(request: ProofRequest): boolean {
-    this.pending = {
-      request,
-      baseline: null,
-    };
-    return true;
-  }
-
-  offer(sample: CodecProofRouteSample): void {
-    const pending = this.pending;
-    if (!pending) return;
-    if (!sameRequestRoute(pending.request, sample)) {
-      return;
-    }
-    const current = decodedBaseline(sample.metrics);
-    if (!current) return;
-    if (!pending.baseline) {
-      pending.baseline = current;
-      return;
-    }
-    if (current.sampleTimestampMs <= pending.baseline.sampleTimestampMs) {
-      return;
-    }
-    if (!sameRtpIdentity(pending.baseline, current)) {
-      pending.baseline = current;
-      return;
-    }
-    const framesDecodedDelta = sample.metrics?.intervalFramesDecoded;
-    if (
-      framesDecodedDelta === null ||
-      framesDecodedDelta === undefined ||
-      !Number.isSafeInteger(framesDecodedDelta) ||
-      framesDecodedDelta <= 0
-    ) {
-      return;
-    }
-    const evidence = codecProofEvidenceSchema.safeParse({
-      baselineSampleTimestampMs: pending.baseline.sampleTimestampMs,
-      sampleTimestampMs: current.sampleTimestampMs,
-      rtpStatsId: current.rtpStatsId,
-      rtpSsrc: current.rtpSsrc,
-      rtpMid: current.rtpMid,
-      rtpRid: current.rtpRid,
-      trackIdentifier: current.trackIdentifier,
-      framesDecodedDelta,
-      actualCodec: actualVideoCodec(sample.metrics?.codec ?? null),
-    });
-    if (!evidence.success) return;
-    if (
-      this.send({
-        type: "video-codec-proof",
-        shareGeneration: pending.request.shareGeneration,
-        generation: pending.request.generation,
-        resumeAttempt: pending.request.resumeAttempt,
-        routeRevision: pending.request.routeRevision,
-        binding: pending.request.binding,
-        evidence: evidence.data,
-      })
-    ) {
-      this.pending = null;
-    }
-  }
-
-  clear(): void {
-    this.pending = null;
-  }
-}
-
-function sameRequestRoute(
-  request: ProofRequest,
-  sample: CodecProofRouteSample,
-): boolean {
-  return (
-    request.routeRevision === sample.routeRevision &&
-    sameProofBinding(request.binding, sample.binding)
-  );
-}
-
-function sameProofBinding(
-  left: CodecProofBinding,
-  right: CodecProofBinding,
-): boolean {
-  return (
-    left.kind === right.kind &&
-    left.connectionId === right.connectionId &&
-    (left.kind === "peer" ||
-      (right.kind === "sfu" &&
-        left.publicationGeneration === right.publicationGeneration))
-  );
-}
-
-function decodedBaseline(
-  metrics: ConnectionMetrics | null,
-): DecodedBaseline | null {
-  if (
-    !metrics ||
-    !Number.isFinite(metrics.sampleTimestampMs) ||
-    metrics.sampleTimestampMs === null ||
-    metrics.sampleTimestampMs < 0 ||
-    !validIdentityString(metrics.rtpStatsId) ||
-    !validOptionalIdentityString(metrics.rtpMid) ||
-    !validOptionalIdentityString(metrics.rtpRid) ||
-    !validOptionalIdentityString(metrics.trackIdentifier) ||
-    (metrics.rtpSsrc !== null &&
-      (!Number.isSafeInteger(metrics.rtpSsrc) ||
-        metrics.rtpSsrc < 0 ||
-        metrics.rtpSsrc > 0xffff_ffff))
-  ) {
-    return null;
-  }
-  return {
-    sampleTimestampMs: metrics.sampleTimestampMs,
-    rtpStatsId: metrics.rtpStatsId,
-    rtpSsrc: metrics.rtpSsrc,
-    rtpMid: metrics.rtpMid,
-    rtpRid: metrics.rtpRid,
-    trackIdentifier: metrics.trackIdentifier,
-  };
-}
-
-function validIdentityString(value: string | null): value is string {
-  return value !== null && value.length >= 1 && value.length <= 512;
-}
-
-function validOptionalIdentityString(value: string | null): boolean {
-  return value === null || validIdentityString(value);
-}
-
-function sameRtpIdentity(
-  left: DecodedBaseline,
-  right: DecodedBaseline,
-): boolean {
-  return (
-    left.rtpStatsId === right.rtpStatsId &&
-    left.rtpSsrc === right.rtpSsrc &&
-    left.rtpMid === right.rtpMid &&
-    left.rtpRid === right.rtpRid &&
-    left.trackIdentifier === right.trackIdentifier
-  );
-}
-
-function actualVideoCodec(codec: string | null): "h264" | "vp8" | "other" {
-  const normalized = codec?.toLowerCase() ?? "";
-  if (normalized.includes("h264")) return "h264";
-  if (normalized.includes("vp8")) return "vp8";
-  return "other";
-}
diff --git a/src/client/media/host-sfu-route.ts b/src/client/media/host-sfu-route.ts
index 3223572..5f38d62 100644
--- a/src/client/media/host-sfu-route.ts
+++ b/src/client/media/host-sfu-route.ts
@@ -1,12 +1,8 @@
 import type {
   ClientMessage,
-  CodecPreparationBinding,
-  CodecTransitionGeneration,
   MediaRoutePhase,
   ParticipantRouteAssignment,
-  PreparedRouteCandidate,
   ServerMessage,
-  VideoCodecPreference,
 } from "../../shared/protocol";
 import {
   SfuPublisher,
@@ -47,8 +43,6 @@ interface HostPublisherSlot {
   connected: boolean;
   active: boolean;
   failed: boolean;
-  codecTransition: PreparedRouteCandidate["codecTransition"];
-  codecPreparationReported: boolean;
 }
 
 export interface HostSfuPublisherSnapshot {
@@ -57,22 +51,12 @@ export interface HostSfuPublisherSnapshot {
   audioSenderParameters: AudioSenderParameterReadback | null;
 }
 
-export interface HostSfuCodecPreparationResult {
-  generation: CodecTransitionGeneration;
-  videoCodec: VideoCodecPreference;
-  binding: Extract<CodecPreparationBinding, { kind: "sfu" }>;
-  accepted: boolean;
-}
-
 interface HostSfuRouteEvents {
   getStream: () => MediaStream | null;
   getProfile: () => QualityProfile;
   reconcileChildren: (childPeerIds: string[]) => void;
   send: (message: ClientMessage) => boolean;
   onPublisherUpdate?: (snapshot: HostSfuPublisherSnapshot | null) => void;
-  onCodecPublisherPrepared?: (
-    result: HostSfuCodecPreparationResult,
-  ) => void;
   createPublisher?: (
     onDisconnected: () => void,
     onStats: (metrics: ConnectionMetrics | null) => void,
@@ -112,11 +96,7 @@ export class HostSfuRoute {
     if (pausedActiveReconciliation) {
       this.events.reconcileChildren(update.assignment.childPeerIds);
     }
-    if (
-      this.paused &&
-      update.phase === "prepare" &&
-      !isPausedCodecSfuCandidate(update)
-    ) {
+    if (this.paused && update.phase === "prepare") {
       this.clearPending();
       return result;
     }
@@ -219,7 +199,7 @@ export class HostSfuRoute {
     if (
       this.closed ||
       !this.route.acceptsConfig(message.revision) ||
-      (this.paused && !this.hasPausedCodecSfuCandidate())
+      this.paused
     ) {
       return;
     }
@@ -228,8 +208,6 @@ export class HostSfuRoute {
     const phase = this.route.getPhase();
     const candidate = this.route.getPreparedCandidate();
     const publicationGeneration = assignment?.sfuPublicationGeneration;
-    const codecTransition =
-      phase === "prepare" ? candidate?.codecTransition ?? null : null;
     if (
       !token ||
       !phase ||
@@ -239,18 +217,6 @@ export class HostSfuRoute {
     ) {
       return;
     }
-    if (
-      codecTransition !== null &&
-      this.active?.publicationGeneration === publicationGeneration
-    ) {
-      this.events.onCodecPublisherPrepared?.({
-        ...codecTransition,
-        binding: { kind: "sfu", publicationGeneration },
-        accepted: false,
-      });
-      this.routeFailed(message.revision, "prepare", null);
-      return;
-    }
     if (this.active?.publicationGeneration === publicationGeneration) {
       this.active.revision = message.revision;
       if (phase === "active" && this.active.active) {
@@ -284,8 +250,6 @@ export class HostSfuRoute {
       connected: false,
       active: false,
       failed: false,
-      codecTransition: codecTransition ? { ...codecTransition } : null,
-      codecPreparationReported: false,
     };
     this.pending = slot;
     try {
@@ -330,7 +294,7 @@ export class HostSfuRoute {
 
   setPaused(paused: boolean): void {
     this.paused = paused;
-    if (paused && !this.hasPausedCodecSfuCandidate()) {
+    if (paused) {
       this.clearPending();
     }
   }
@@ -342,7 +306,7 @@ export class HostSfuRoute {
       : Promise.all(
           slots.map((slot) =>
             slot.publisher
-              .updateProfile(this.profileForSlot(slot, profile))
+              .updateProfile(profile)
               .catch(() => false),
           ),
         ).then((results) => results.every(Boolean));
@@ -516,7 +480,7 @@ export class HostSfuRoute {
 
   private async preparePublisher(slot: HostPublisherSlot): Promise<boolean> {
     const stream = this.events.getStream();
-    const profile = this.profileForSlot(slot, this.events.getProfile());
+    const profile = this.events.getProfile();
     if (!stream) {
       this.handleFailure(slot);
       return false;
@@ -542,7 +506,7 @@ export class HostSfuRoute {
         await disconnectPublisher(slot.publisher);
         return false;
       }
-      const latestProfile = this.profileForSlot(slot, this.events.getProfile());
+      const latestProfile = this.events.getProfile();
       if (
         !qualitySettingsEqual(latestProfile, profile) &&
         !(await slot.publisher.updateProfile(latestProfile))
@@ -551,11 +515,7 @@ export class HostSfuRoute {
         await disconnectPublisher(slot.publisher);
         return false;
       }
-      const prepared = this.pending === slot && this.ownsPublisherSlot(slot);
-      if (prepared) {
-        this.reportCodecPreparation(slot, true);
-      }
-      return prepared;
+      return this.pending === slot && this.ownsPublisherSlot(slot);
     } catch {
       this.handleFailure(slot);
       await disconnectPublisher(slot.publisher);
@@ -571,42 +531,6 @@ export class HostSfuRoute {
     );
   }
 
-  private hasPausedCodecSfuCandidate(): boolean {
-    const candidate = this.route.getPreparedCandidate();
-    return (
-      this.route.getPhase() === "prepare" &&
-      candidate?.transport === "sfu" &&
-      candidate.codecTransition !== null
-    );
-  }
-
-  private profileForSlot(
-    slot: HostPublisherSlot,
-    profile: QualityProfile,
-  ): QualityProfile {
-    return slot.codecTransition
-      ? { ...profile, videoCodec: slot.codecTransition.videoCodec }
-      : profile;
-  }
-
-  private reportCodecPreparation(
-    slot: HostPublisherSlot,
-    accepted: boolean,
-  ): void {
-    if (!slot.codecTransition || slot.codecPreparationReported) {
-      return;
-    }
-    slot.codecPreparationReported = true;
-    this.events.onCodecPublisherPrepared?.({
-      ...slot.codecTransition,
-      binding: {
-        kind: "sfu",
-        publicationGeneration: slot.publicationGeneration,
-      },
-      accepted,
-    });
-  }
-
   private currentActiveToken(
     slot: HostPublisherSlot,
   ): RouteOperationToken | null {
@@ -699,9 +623,6 @@ export class HostSfuRoute {
       this.active = null;
     }
 
-    if (matchesPlannedRoute) {
-      this.reportCodecPreparation(slot, false);
-    }
     if (revision === null || phase === null) {
       return;
     }
@@ -769,14 +690,6 @@ export class HostSfuRoute {
   }
 }
 
-function isPausedCodecSfuCandidate(update: RouteUpdateInput): boolean {
-  return (
-    update.phase === "prepare" &&
-    update.candidate.transport === "sfu" &&
-    update.candidate.codecTransition !== null
-  );
-}
-
 async function disconnectPublisher(
   publisher: HostPublisherTransport,
 ): Promise<void> {
diff --git a/src/client/media/host-source-authority.ts b/src/client/media/host-source-authority.ts
deleted file mode 100644
index 76acc49..0000000
--- a/src/client/media/host-source-authority.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import type {
-  CodecTransitionGeneration,
-  ResumeAttempt,
-  ServerMessage,
-} from "../../shared/protocol";
-import { setMediaPaused } from "./quality";
-
-type PauseSharingSourceMessage = Extract<
-  ServerMessage,
-  { type: "pause-sharing-source" }
->;
-
-interface AuthoritativeHostPauseInput {
-  message: PauseSharingSourceMessage;
-  currentShareGeneration: string | null;
-  activeResumeAttempt: ResumeAttempt | null;
-  activeCodecGeneration: CodecTransitionGeneration | null;
-  stream: MediaStream | null;
-  pauseSfuRoute: () => void;
-  markHostPaused: () => void;
-}
-
-export interface AuthoritativeHostPauseResult {
-  localCodecContextMatches: boolean;
-}
-
-export function applyAuthoritativeHostPause({
-  message,
-  currentShareGeneration,
-  activeResumeAttempt,
-  activeCodecGeneration,
-  stream,
-  pauseSfuRoute,
-  markHostPaused,
-}: AuthoritativeHostPauseInput): AuthoritativeHostPauseResult | null {
-  if (message.shareGeneration !== currentShareGeneration) {
-    return null;
-  }
-
-  if (stream) {
-    setMediaPaused(stream, true);
-  }
-  pauseSfuRoute();
-  markHostPaused();
-
-  return {
-    localCodecContextMatches:
-      (message.resumeAttempt === null ||
-        message.resumeAttempt === activeResumeAttempt) &&
-      (message.codecGeneration === null ||
-        message.codecGeneration === activeCodecGeneration),
-  };
-}
diff --git a/src/client/media/quality.ts b/src/client/media/quality.ts
index 9645d60..cb87139 100644
--- a/src/client/media/quality.ts
+++ b/src/client/media/quality.ts
@@ -26,7 +26,7 @@ export const QUALITY_PROFILES = {
     maxFramerate: 60,
     maxBitrate: 8_000_000,
     degradationPreference: "balanced",
-    videoCodec: "automatic",
+    videoCodec: "vp8",
     screenAudioQuality: "music",
   },
   "1080p30": DEFAULT_QUALITY_SETTINGS,
@@ -35,7 +35,7 @@ export const QUALITY_PROFILES = {
     maxFramerate: 30,
     maxBitrate: 3_000_000,
     degradationPreference: "balanced",
-    videoCodec: "automatic",
+    videoCodec: "vp8",
     screenAudioQuality: "music",
   },
 } as const satisfies Record<QualityProfileId, QualitySettings>;
@@ -145,7 +145,7 @@ export function videoQualitySettingsEqual(
     left.maxFramerate === right.maxFramerate &&
     left.maxBitrate === right.maxBitrate &&
     left.degradationPreference === right.degradationPreference &&
-    (left.videoCodec ?? "automatic") === (right.videoCodec ?? "automatic")
+    (left.videoCodec ?? "vp8") === (right.videoCodec ?? "vp8")
   );
 }
 
diff --git a/src/client/media/route-transition.ts b/src/client/media/route-transition.ts
index d45aa38..6935e7f 100644
--- a/src/client/media/route-transition.ts
+++ b/src/client/media/route-transition.ts
@@ -151,34 +151,14 @@ function sameCandidate(
   return (
     left?.childPeerId === right.childPeerId &&
     left.connectionId === right.connectionId &&
-    left.transport === right.transport &&
-    sameCodecTransition(left.codecTransition, right.codecTransition)
-  );
-}
-
-function sameCodecTransition(
-  left: PreparedRouteCandidate["codecTransition"] | undefined,
-  right: PreparedRouteCandidate["codecTransition"],
-): boolean {
-  return (
-    left === right ||
-    (left !== null &&
-      left !== undefined &&
-      right !== null &&
-      left.generation === right.generation &&
-      left.videoCodec === right.videoCodec)
+    left.transport === right.transport
   );
 }
 
 function cloneCandidate(
   candidate: PreparedRouteCandidate,
 ): PreparedRouteCandidate {
-  return {
-    ...candidate,
-    codecTransition: candidate.codecTransition
-      ? { ...candidate.codecTransition }
-      : null,
-  };
+  return { ...candidate };
 }
 
 export function reportActivePeerRouteFailure(
diff --git a/src/client/media/viewer-sfu-route.ts b/src/client/media/viewer-sfu-route.ts
index f82762c..5eebcf7 100644
--- a/src/client/media/viewer-sfu-route.ts
+++ b/src/client/media/viewer-sfu-route.ts
@@ -119,11 +119,7 @@ export class ViewerSfuRoute {
     if (pausedActiveReconciliation) {
       this.activateChildren(update.assignment.childPeerIds, update.revision);
     }
-    if (
-      this.paused &&
-      update.phase === "prepare" &&
-      !isPausedCodecSfuCandidate(update)
-    ) {
+    if (this.paused && update.phase === "prepare") {
       this.discardPending();
       return result;
     }
@@ -203,21 +199,9 @@ export class ViewerSfuRoute {
   }
 
   setPaused(paused: boolean): void {
-    const wasPaused = this.paused;
     this.paused = paused;
-    if (paused && !this.hasPausedCodecSfuCandidate()) {
+    if (paused) {
       this.discardPending();
-    } else if (paused && this.pending) {
-      this.pending.decodedFrame = false;
-      this.pending.readySent = false;
-      this.pending.subscriber.stopDecodedFrameProof();
-    } else if (
-      wasPaused &&
-      !paused &&
-      this.pending &&
-      this.hasPausedCodecSfuCandidate()
-    ) {
-      this.pending.subscriber.armDecodedFrameProof(true);
     }
   }
 
@@ -294,7 +278,7 @@ export class ViewerSfuRoute {
     if (
       this.closed ||
       !this.route.acceptsConfig(message.revision) ||
-      (this.paused && !this.hasPausedCodecSfuCandidate())
+      this.paused
     ) {
       return;
     }
@@ -461,16 +445,6 @@ export class ViewerSfuRoute {
     );
   }
 
-  private hasPausedCodecSfuCandidate(): boolean {
-    const candidate = this.route.getPreparedCandidate();
-    return (
-      this.route.getPhase() === "prepare" &&
-      candidate?.childPeerId === this.viewerPeerId &&
-      candidate.transport === "sfu" &&
-      candidate.codecTransition !== null
-    );
-  }
-
   private queueActiveRoute(
     token: RouteOperationToken,
     acknowledge: boolean,
@@ -804,14 +778,6 @@ export class ViewerSfuRoute {
 
 }
 
-function isPausedCodecSfuCandidate(update: RouteUpdateInput): boolean {
-  return (
-    update.phase === "prepare" &&
-    update.candidate.transport === "sfu" &&
-    update.candidate.codecTransition !== null
-  );
-}
-
 async function disconnectSubscriber(
   subscriber: ViewerSubscriberTransport,
 ): Promise<void> {
diff --git a/src/client/pages/HostPage.tsx b/src/client/pages/HostPage.tsx
index ae8f46d..47f89fa 100644
--- a/src/client/pages/HostPage.tsx
+++ b/src/client/pages/HostPage.tsx
@@ -28,8 +28,6 @@ import {
   type PreparedRouteCandidate,
   type ServerMessage,
   type CodeEntryPolicy,
-  type CodecTransitionGeneration,
-  type ResumeAttempt,
 } from "../../shared/protocol";
 import { AppHeader } from "../components/AppHeader";
 import { ConnectionSelfCheck } from "../components/ConnectionSelfCheck";
@@ -98,7 +96,6 @@ import {
   HostSfuRoute,
   type HostSfuPublisherSnapshot,
 } from "../media/host-sfu-route";
-import { applyAuthoritativeHostPause } from "../media/host-source-authority";
 import {
   HostProvisionalChild,
 } from "../media/host-provisional-child";
@@ -128,24 +125,10 @@ import {
   shouldPauseLocalPreview,
   sourceSwitchNotice,
   type HostAction,
-  VIDEO_CODEC_TRANSITION_FAILED_NOTICE,
   videoCodecLockNotice,
 } from "./host-page-notices";
 
 type HostPhase = "idle" | "starting" | "live" | "ended" | "error";
-type CodecTransitionPhase =
-  | "preparing"
-  | "prepared"
-  | "proving"
-  | "rollback-preparing"
-  | "rollback-prepared"
-  | "failed";
-
-interface CodecTransitionState {
-  generation: CodecTransitionGeneration | null;
-  requested: VideoCodecPreference;
-  rollback: boolean;
-}
 
 type ViewerQualityEvidence = Extract<
   ServerMessage,
@@ -291,9 +274,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
   const [switchingSource, setSwitchingSource] = useState(false);
   const [changingQuality, setChangingQuality] = useState(false);
   const [sharingPaused, setSharingPaused] = useState(false);
-  const [resumePending, setResumePending] = useState(false);
-  const [codecTransitionPhase, setCodecTransitionPhase] =
-    useState<CodecTransitionPhase | null>(null);
   const [localPreviewPaused, setLocalPreviewPaused] = useState(false);
   const [showConnectionDetails, setShowConnectionDetails] = useState(false);
   const [showTopology, setShowTopology] = useState(false);
@@ -329,10 +309,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
   const qualityChangeRef = useRef<object | null>(null);
   const qualitySettingsRef = useRef<QualitySettings>(DEFAULT_QUALITY_SETTINGS);
   const sharingPausedRef = useRef(false);
-  const resumePendingRef = useRef(false);
-  const activeResumeAttemptRef = useRef<ResumeAttempt | null>(null);
-  const codecTransitionRef = useRef<CodecTransitionState | null>(null);
-  const codecTransitionPhaseRef = useRef<CodecTransitionPhase | null>(null);
   const retiringStreamRef = useRef<MediaStream | null>(null);
   const hostSfuRouteRef = useRef<HostSfuRoute | null>(null);
   const sfuStandbyPrewarmerRef = useRef<SfuStandbyPrewarmer | null>(null);
@@ -510,31 +486,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
           setSfuPublisherSnapshot(snapshot);
         }
       },
-      onCodecPublisherPrepared: (result) => {
-        const shareGeneration = shareGenerationRef.current;
-        if (
-          !shareGeneration ||
-          !isCurrentGeneration(generation) ||
-          hostSfuRouteRef.current !== route
-        ) {
-          return;
-        }
-        const rollback =
-          codecTransitionRef.current?.rollback === true ||
-          codecTransitionPhaseRef.current === "rollback-preparing";
-        codecTransitionRef.current = {
-          generation: result.generation,
-          requested: result.videoCodec,
-          rollback,
-        };
-        signalRef.current?.send({
-          type: "video-codec-prepared",
-          shareGeneration,
-          generation: result.generation,
-          binding: result.binding,
-          accepted: result.accepted,
-        });
-      },
     });
     hostSfuRouteRef.current = route;
     return route;
@@ -625,12 +576,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
     setChangingQuality(false);
     sharingPausedRef.current = false;
     setSharingPaused(false);
-    resumePendingRef.current = false;
-    setResumePending(false);
-    activeResumeAttemptRef.current = null;
-    codecTransitionRef.current = null;
-    codecTransitionPhaseRef.current = null;
-    setCodecTransitionPhase(null);
   }
 
   function forgetRoom(): void {
@@ -794,45 +739,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
   }
 
   function changeVideoCodec(videoCodec: VideoCodecPreference): void {
-    if (phase === "starting") {
-      return;
-    }
-    if (phase === "live") {
-      const shareGeneration = shareGenerationRef.current;
-      if (
-        !sharingPausedRef.current ||
-        !peerAssistedRef.current ||
-        !shareGeneration ||
-        changingQuality ||
-        switchingSource ||
-        codecTransitionRef.current
-      ) {
-        return;
-      }
-      if (
-        (qualitySettingsRef.current.videoCodec ?? "automatic") === videoCodec
-      ) {
-        return;
-      }
-      if (
-        signalRef.current?.send({
-          type: "request-video-codec-transition",
-          shareGeneration,
-          videoCodec,
-        }) !== true
-      ) {
-        setNotice("信令正在恢复，暂时无法切换视频编码");
-        return;
-      }
-      codecTransitionRef.current = {
-        generation: null,
-        requested: videoCodec,
-        rollback: false,
-      };
-      codecTransitionPhaseRef.current = "preparing";
-      setCodecTransitionPhase("preparing");
-      setAdvancedQuality((current) => ({ ...current, videoCodec }));
-      setNotice("正在准备视频编码");
+    if (phase === "starting" || phase === "live") {
       return;
     }
     const next = { ...qualitySettingsRef.current, videoCodec };
@@ -856,24 +763,10 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
     preserveAdvancedDraft = false,
   ): Promise<void> {
     const previousProfile = qualitySettingsRef.current;
-    const codecTransition = codecTransitionRef.current;
     if (
       phase === "live" &&
-      (nextProfile.videoCodec ?? "automatic") !==
-        (previousProfile.videoCodec ?? "automatic")
-    ) {
-      return;
-    }
-    if (
-      phase === "live" &&
-      codecTransition &&
-      !videoQualitySettingsEqual(previousProfile, nextProfile)
-    ) {
-      return;
-    }
-    if (
-      phase === "live" &&
-      codecTransitionPhaseRef.current === "failed"
+      (nextProfile.videoCodec ?? "vp8") !==
+        (previousProfile.videoCodec ?? "vp8")
     ) {
       return;
     }
@@ -905,10 +798,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
     const audioChanged =
       resolveScreenAudioQuality(previousProfile.screenAudioQuality) !==
       resolveScreenAudioQuality(nextProfile.screenAudioQuality);
-    const endpointProfile = codecTransition
-      ? { ...nextProfile, videoCodec: codecTransition.requested }
-      : nextProfile;
-
     try {
       if (videoChanged) {
         await applyCaptureProfile(activeStream, nextProfile);
@@ -936,14 +825,14 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
         Promise.all(
           [
             ...[...peersRef.current.values()].map((peer) =>
-              peer.updateProfile(endpointProfile),
+              peer.updateProfile(nextProfile),
             ),
             ...(hostProvisionalChildRef.current
-              ? [hostProvisionalChildRef.current.updateProfile(endpointProfile)]
+              ? [hostProvisionalChildRef.current.updateProfile(nextProfile)]
               : []),
           ],
         ),
-        activeSfuRoute?.updateProfile(endpointProfile) ??
+        activeSfuRoute?.updateProfile(nextProfile) ??
           Promise.resolve(true),
       ]);
       if (
@@ -994,16 +883,21 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
       return;
     }
     if (sharingPausedRef.current) {
-      if (resumePendingRef.current) {
+      if (!setMediaPaused(activeStream, false)) {
+        setNotice("当前分享没有可恢复的媒体轨道");
         return;
       }
-      if (signalRef.current?.requestSharingResume() !== true) {
+      hostSfuRouteRef.current?.setPaused(false);
+      if (signalRef.current?.setSharingPaused(false) !== true) {
+        setMediaPaused(activeStream, true);
+        hostSfuRouteRef.current?.setPaused(true);
+        signalRef.current?.confirmSharingPaused();
         setNotice("信令正在恢复，分享仍保持暂停");
         return;
       }
-      resumePendingRef.current = true;
-      setResumePending(true);
-      setNotice("正在恢复分享");
+      sharingPausedRef.current = false;
+      setSharingPaused(false);
+      setNotice("音视频分享已恢复");
       return;
     }
     if (!setMediaPaused(activeStream, true)) {
@@ -1014,17 +908,11 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
     setSharingPaused(true);
     hostSfuRouteRef.current?.setPaused(true);
     discardPreparedHostChild();
-    signalRef.current?.pauseSharing();
-    activeResumeAttemptRef.current = null;
-    const codecState = codecTransitionRef.current;
-    if (codecState && codecTransitionPhaseRef.current === "proving") {
-      const nextPhase = codecState.rollback
-        ? "rollback-prepared"
-        : "prepared";
-      codecTransitionPhaseRef.current = nextPhase;
-      setCodecTransitionPhase(nextPhase);
-    }
-    setNotice("音视频分享已暂停");
+    setNotice(
+      signalRef.current?.setSharingPaused(true) === true
+        ? "音视频分享已暂停"
+        : "信令正在恢复，分享保持暂停",
+    );
   }
 
   async function enterPreviewFullscreen(): Promise<void> {
@@ -1280,55 +1168,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
     );
   }
 
-  async function prepareVideoCodec(
-    message: Extract<ServerMessage, { type: "video-codec-prepare" }>,
-    generation: number,
-  ): Promise<void> {
-    const shareGeneration = shareGenerationRef.current;
-    if (
-      !shareGeneration ||
-      message.shareGeneration !== shareGeneration ||
-      !isCurrentGeneration(generation)
-    ) {
-      return;
-    }
-
-    const rollback =
-      codecTransitionRef.current?.rollback === true ||
-      codecTransitionPhaseRef.current === "rollback-preparing";
-    codecTransitionRef.current = {
-      generation: message.generation,
-      requested: message.videoCodec,
-      rollback,
-    };
-
-    let accepted = false;
-    if (message.binding.kind === "peer") {
-      const peer = peersRef.current.get(message.binding.childPeerId);
-      if (peer?.connectionId === message.binding.connectionId) {
-        peer.cancelVideoCodecPreparation();
-        accepted = await peer.prepareVideoCodec(
-          message.generation,
-          message.videoCodec,
-        );
-      }
-    }
-
-    if (
-      !isCurrentGeneration(generation) ||
-      shareGenerationRef.current !== shareGeneration
-    ) {
-      return;
-    }
-    signalRef.current?.send({
-      type: "video-codec-prepared",
-      shareGeneration,
-      generation: message.generation,
-      binding: message.binding,
-      accepted,
-    });
-  }
-
   function handleSignalMessage(
     message: ServerMessage,
     generation: number,
@@ -1339,15 +1178,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
       return;
     }
     if (message.type === "authenticated" && message.role === "host") {
-      peersRef.current.forEach((peer) =>
-        peer.cancelVideoCodecPreparation(),
-      );
-      codecTransitionRef.current = null;
-      codecTransitionPhaseRef.current = null;
-      setCodecTransitionPhase(null);
-      resumePendingRef.current = false;
-      setResumePending(false);
-      activeResumeAttemptRef.current = null;
       discardPreparedHostChild();
       hostPeerIdRef.current = message.peerId;
       endpointMediaCopyCapacityRef.current = message.endpointMediaCopyCapacity;
@@ -1374,32 +1204,21 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
           ...message.routeAssignment.childPeerIds,
         ];
         peerAssistedRef.current = true;
-        const activeCodecTransition = codecTransitionRef.current;
         if (reauthenticated) {
-          commitQuality(
-            message.qualitySettings,
-            activeCodecTransition !== null,
-          );
-          if (activeCodecTransition === null) {
-            const endpointUpdates = [
-              ...[...peersRef.current.values()].map((peer) =>
-                peer.updateProfile(message.qualitySettings),
-              ),
-              ...(hostProvisionalChildRef.current
-                ? [
-                    hostProvisionalChildRef.current.updateProfile(
-                      message.qualitySettings,
-                    ),
-                  ]
-                : []),
-            ];
-            void Promise.allSettled(endpointUpdates);
-          }
-        } else {
-          signalRef.current?.send({
-            type: "set-quality-settings",
-            qualitySettings: qualitySettingsRef.current,
-          });
+          commitQuality(message.qualitySettings);
+          const endpointUpdates = [
+            ...[...peersRef.current.values()].map((peer) =>
+              peer.updateProfile(message.qualitySettings),
+            ),
+            ...(hostProvisionalChildRef.current
+              ? [
+                  hostProvisionalChildRef.current.updateProfile(
+                    message.qualitySettings,
+                  ),
+                ]
+              : []),
+          ];
+          void Promise.allSettled(endpointUpdates);
         }
         const route = ensureHostSfuRoute(generation);
         void route
@@ -1409,11 +1228,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
             assignment: message.routeAssignment,
           })
           .then(async () => {
-            if (
-              reauthenticated &&
-              codecTransitionRef.current === null &&
-              hostSfuRouteRef.current === route
-            ) {
+            if (reauthenticated && hostSfuRouteRef.current === route) {
               await route.updateProfile(message.qualitySettings);
             }
             showHostSfuQualityWarning(route, generation);
@@ -1503,166 +1318,19 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
       downloadDiagnosticReport("host", connections, message.snapshot);
       return;
     }
-    if (message.type === "video-codec-prepare") {
-      void prepareVideoCodec(message, generation);
-      return;
-    }
-    if (message.type === "video-codec-result") {
-      let transition = codecTransitionRef.current;
-      if (
-        !transition &&
-        message.status === "failed" &&
-        message.failure === "stale-binding"
-      ) {
-        transition = {
-          generation: message.generation,
-          requested: message.videoCodec,
-          rollback: true,
-        };
-        codecTransitionRef.current = transition;
-      }
-      if (
-        !transition ||
-        (transition.generation !== null &&
-          transition.generation !== message.generation)
-      ) {
-        return;
-      }
-      transition.generation = message.generation;
-      if (message.status === "prepared") {
-        codecTransitionPhaseRef.current = "prepared";
-        setCodecTransitionPhase("prepared");
-        setNotice("视频编码已准备，恢复分享后完成验证");
-        return;
-      }
-      if (message.status === "rollback-prepared") {
-        transition.rollback = true;
-        transition.requested = message.videoCodec;
-        codecTransitionPhaseRef.current = "rollback-prepared";
-        setCodecTransitionPhase("rollback-prepared");
-        setAdvancedQuality((current) => ({
-          ...current,
-          videoCodec: message.videoCodec,
-        }));
-        setNotice("新编码未通过验证；原编码已准备，恢复分享后完成恢复");
-        return;
-      }
-      if (message.status === "committed") {
-        activeResumeAttemptRef.current = null;
-        codecTransitionRef.current = null;
-        codecTransitionPhaseRef.current = null;
-        setCodecTransitionPhase(null);
-        commitQuality(
-          { ...qualitySettingsRef.current, videoCodec: message.videoCodec },
-          true,
-        );
-        setAdvancedQuality((current) => ({
-          ...current,
-          videoCodec: message.videoCodec,
-        }));
-        setNotice(
-          message.failure
-            ? "已恢复原视频编码"
-            : `视频编码已切换为 ${VIDEO_CODEC_PREFERENCE_LABELS[message.videoCodec]}`,
-        );
-      } else {
-        transition.requested = message.videoCodec;
-        transition.rollback = true;
-        codecTransitionPhaseRef.current = "failed";
-        setCodecTransitionPhase("failed");
-        resumePendingRef.current = false;
-        setResumePending(false);
-        activeResumeAttemptRef.current = null;
-        setAdvancedQuality((current) => ({
-          ...current,
-          videoCodec: message.videoCodec,
-        }));
-        setNotice(VIDEO_CODEC_TRANSITION_FAILED_NOTICE);
-      }
-      return;
-    }
-    if (message.type === "sharing-resume-authorized") {
+    if (message.type === "pause-sharing-source") {
       if (message.shareGeneration !== shareGenerationRef.current) {
         return;
       }
-      const transition = codecTransitionRef.current;
-      if (
-        (message.codecGeneration === null && transition !== null) ||
-        (message.codecGeneration !== null &&
-          (transition?.generation !== message.codecGeneration ||
-            (codecTransitionPhaseRef.current !== "prepared" &&
-              codecTransitionPhaseRef.current !== "rollback-prepared")))
-      ) {
-        activeResumeAttemptRef.current = null;
-        signalRef.current?.pauseSharing();
-        resumePendingRef.current = false;
-        setResumePending(false);
-        setNotice("恢复授权已失效，分享仍保持暂停");
-        return;
-      }
-      activeResumeAttemptRef.current = message.resumeAttempt;
       const activeStream = streamRef.current;
-      if (!activeStream || !setMediaPaused(activeStream, false)) {
-        activeResumeAttemptRef.current = null;
-        signalRef.current?.pauseSharing();
-        resumePendingRef.current = false;
-        setResumePending(false);
-        setNotice("当前分享没有可恢复的媒体轨道");
-        return;
-      }
-      hostSfuRouteRef.current?.setPaused(false);
-      if (signalRef.current?.confirmSharingResumed(message) !== true) {
+      if (activeStream) {
         setMediaPaused(activeStream, true);
-        hostSfuRouteRef.current?.setPaused(true);
-        signalRef.current?.pauseSharing();
-        activeResumeAttemptRef.current = null;
-        resumePendingRef.current = false;
-        setResumePending(false);
-        setNotice("信令正在恢复，分享仍保持暂停");
-        return;
-      }
-      sharingPausedRef.current = false;
-      setSharingPaused(false);
-      resumePendingRef.current = false;
-      setResumePending(false);
-      if (message.codecGeneration !== null) {
-        codecTransitionPhaseRef.current = "proving";
-        setCodecTransitionPhase("proving");
-        setNotice("正在验证视频编码");
-      } else {
-        setNotice("音视频分享已恢复");
-      }
-      return;
-    }
-    if (message.type === "pause-sharing-source") {
-      const transition = codecTransitionRef.current;
-      const pause = applyAuthoritativeHostPause({
-        message,
-        currentShareGeneration: shareGenerationRef.current,
-        activeResumeAttempt: activeResumeAttemptRef.current,
-        activeCodecGeneration: transition?.generation ?? null,
-        stream: streamRef.current,
-        pauseSfuRoute: () => hostSfuRouteRef.current?.setPaused(true),
-        markHostPaused: () => {
-          sharingPausedRef.current = true;
-          setSharingPaused(true);
-          signalRef.current?.confirmSharingPaused();
-          resumePendingRef.current = false;
-          setResumePending(false);
-          activeResumeAttemptRef.current = null;
-        },
-      });
-      if (!pause) {
-        return;
-      }
-      if (transition && pause.localCodecContextMatches) {
-        transition.rollback = true;
-        codecTransitionPhaseRef.current = "rollback-preparing";
-        setCodecTransitionPhase("rollback-preparing");
-        setNotice("新编码未通过验证，正在恢复原编码");
-      } else {
-        setNotice("分享仍保持暂停");
       }
+      hostSfuRouteRef.current?.setPaused(true);
+      sharingPausedRef.current = true;
+      setSharingPaused(true);
+      signalRef.current?.confirmSharingPaused();
+      setNotice("分享仍保持暂停");
       return;
     }
     if (message.type === "route-update") {
@@ -1779,20 +1447,6 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
       return;
     }
     if (message.type === "error") {
-      if (
-        codecTransitionRef.current?.generation === null &&
-        codecTransitionPhaseRef.current === "preparing"
-      ) {
-        codecTransitionRef.current = null;
-        codecTransitionPhaseRef.current = null;
-        setCodecTransitionPhase(null);
-        setAdvancedQuality((current) => ({
-          ...current,
-          videoCodec: qualitySettingsRef.current.videoCodec ?? "automatic",
-        }));
-      }
-      resumePendingRef.current = false;
-      setResumePending(false);
       setViewerGrantUpdating(false);
       setViewerPasswordUpdating(false);
       viewerPasswordActionRef.current = null;
@@ -1896,6 +1550,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
             clientId: hostClientId,
             shareGeneration,
             sharingPaused: false,
+            qualitySettings: qualitySettingsRef.current,
             viewerPresence: true,
             viewerPasswordSettings: true,
             displayName: initialDisplayName,
@@ -2298,14 +1953,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
     : null;
   const activeCodeEntryPolicy =
     room?.codeEntryPolicy ?? creationProfile.codeEntryPolicy;
-  const codecLockNotice = videoCodecLockNotice(
-    phase,
-    sharingPaused,
-    codecTransitionPhase,
-  );
-  const codecResumeReady =
-    codecTransitionPhase === "prepared" ||
-    codecTransitionPhase === "rollback-prepared";
+  const codecLockNotice = videoCodecLockNotice(phase);
 
   return (
     <div className="app-shell">
@@ -2347,11 +1995,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
                     type="button"
                     disabled={
                       switchingSource ||
-                      changingQuality ||
-                      resumePending ||
-                      (sharingPaused &&
-                        codecTransitionPhase !== null &&
-                        !codecResumeReady)
+                      changingQuality
                     }
                     onClick={toggleSharingPause}
                   >
@@ -2360,11 +2004,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
                     ) : (
                       <Pause size={16} fill="currentColor" aria-hidden="true" />
                     )}
-                    {resumePending
-                      ? "正在恢复"
-                      : sharingPaused
-                        ? "恢复分享"
-                        : "暂停分享"}
+                    {sharingPaused ? "恢复分享" : "暂停分享"}
                   </button>
                 )}
                 {phase === "live" && (
@@ -2373,8 +2013,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
                     type="button"
                     disabled={
                       switchingSource ||
-                      changingQuality ||
-                      codecTransitionPhase !== null
+                      changingQuality
                     }
                     onClick={() => void switchSource()}
                   >
@@ -2606,14 +2245,13 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
                         disabled={
                           phase === "starting" ||
                           switchingSource ||
-                          changingQuality ||
-                          codecTransitionPhase !== null
+                          changingQuality
                         }
                         onClick={() =>
                           void changeQuality({
                             ...QUALITY_PROFILES[id],
                             videoCodec:
-                              qualitySettingsRef.current.videoCodec ?? "automatic",
+                              qualitySettingsRef.current.videoCodec ?? "vp8",
                             screenAudioQuality: resolveScreenAudioQuality(
                               qualitySettingsRef.current.screenAudioQuality,
                             ),
@@ -2743,18 +2381,17 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
                           key={codec}
                           type="button"
                           className={
-                            (advancedQuality.videoCodec ?? "automatic") === codec
+                            (advancedQuality.videoCodec ?? "vp8") === codec
                               ? "is-selected"
                               : undefined
                           }
                           aria-pressed={
-                            (advancedQuality.videoCodec ?? "automatic") === codec
+                            (advancedQuality.videoCodec ?? "vp8") === codec
                           }
                           disabled={
                             phase === "starting" ||
-                            (phase === "live" && !sharingPaused) ||
-                            changingQuality ||
-                            codecTransitionPhase !== null
+                            phase === "live" ||
+                            changingQuality
                           }
                           onClick={() =>
                             changeVideoCodec(codec)
@@ -2796,8 +2433,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
                           disabled={
                             phase === "starting" ||
                             switchingSource ||
-                            changingQuality ||
-                            codecTransitionPhase === "failed"
+                            changingQuality
                           }
                           onClick={() =>
                             changeScreenAudioQuality(audioQuality)
@@ -2814,8 +2450,7 @@ export function HostPage({ onAuthorizationRequired }: HostPageProps = {}) {
                     disabled={
                       phase === "starting" ||
                       switchingSource ||
-                      changingQuality ||
-                      codecTransitionPhase !== null
+                      changingQuality
                     }
                     onClick={() => void changeQuality(advancedQuality)}
                   >
diff --git a/src/client/pages/ViewerPage.tsx b/src/client/pages/ViewerPage.tsx
index 15ddc05..616f81c 100644
--- a/src/client/pages/ViewerPage.tsx
+++ b/src/client/pages/ViewerPage.tsx
@@ -73,10 +73,6 @@ import {
   isAutoplayPolicyRejection,
   observeCompositedVideoFrame,
 } from "../media/video-frame-proof";
-import {
-  CodecProofReporter,
-  type CodecProofRouteSample,
-} from "../media/codec-proof";
 import { exactPeerSignalOwner } from "../media/route-transition";
 import { ViewerSfuRoute } from "../media/viewer-sfu-route";
 import {
@@ -347,8 +343,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
       revision: number;
       connectionId: string;
     } | null = null;
-    let activePeerProofSnapshot: PeerSnapshot | null = null;
-    let activeSfuProofMetrics: ConnectionMetrics | null = null;
     let endpointMediaCopyCapacity = MAX_ENDPOINT_MEDIA_CHILDREN;
     let viewerAuthorizationGeneration: string | null = null;
     let currentQualitySettings: QualitySettings = DEFAULT_QUALITY_SETTINGS;
@@ -440,67 +434,15 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
     const qualityEvidenceReporter = new ViewerQualityEvidenceReporter(
       (message) => active && signal.send(message),
     );
-    const codecProofReporter = new CodecProofReporter(
-      (message) => active && signal.send(message),
-    );
-
-    function currentCodecProofSample(): CodecProofRouteSample | null {
-      const assignment = currentRouteAssignment;
-      const connectionId = currentRouteConnectionId;
-      if (!assignment || !connectionId) {
-        return null;
-      }
-      if (assignment.upstream.kind === "peer") {
-        const snapshot = activePeerProofSnapshot;
-        if (
-          !snapshot ||
-          snapshot.peerId !== assignment.upstream.peerId ||
-          snapshot.connectionId !== connectionId
-        ) {
-          return null;
-        }
-        return {
-          routeRevision: currentRouteRevision,
-          binding: { kind: "peer", connectionId },
-          metrics: snapshot.metrics,
-        };
-      }
-      if (
-        assignment.upstream.kind !== "sfu" ||
-        assignment.sfuPublicationGeneration === null
-      ) {
-        return null;
-      }
-      return {
-        routeRevision: currentRouteRevision,
-        binding: {
-          kind: "sfu",
-          connectionId,
-          publicationGeneration: assignment.sfuPublicationGeneration,
-        },
-        metrics: activeSfuProofMetrics,
-      };
-    }
-
-    function offerCodecProof(): void {
-      const sample = currentCodecProofSample();
-      if (sample) {
-        codecProofReporter.offer(sample);
-      }
-    }
-
-    function activateProofRoute(
+    function activateRouteIdentity(
       revision: number,
       assignment: ParticipantRouteAssignment,
       connectionId: string | null,
     ): void {
-      codecProofReporter.clear();
       currentRouteRevision = revision;
       currentRouteAssignment = assignment;
       currentRouteConnectionId =
         assignment.upstream.kind === "none" ? null : connectionId;
-      activePeerProofSnapshot = null;
-      activeSfuProofMetrics = null;
       pendingRouteConnection = null;
     }
 
@@ -732,8 +674,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
             );
             ensureViewerRelay()?.setStream(probe.stream);
             bindRemoteStream(probe.stream, revision);
-            activePeerProofSnapshot = probe.snapshot;
-            offerCodecProof();
             setPeerSnapshot(probe.snapshot);
             setSfuUpstream(null);
             return true;
@@ -813,10 +753,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
         },
         onSfuUpdate: (metrics, revision) => {
           if (active && viewerSfuRoute === route) {
-            if (revision === currentRouteRevision) {
-              activeSfuProofMetrics = metrics;
-              offerCodecProof();
-            }
             if (metrics) {
               observeActiveDecodedFrames(
                 "sfu",
@@ -895,8 +831,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
       const route = viewerSfuRoute;
       discardPendingPeer();
       viewerSfuRoute = null;
-      activeSfuProofMetrics = null;
-      codecProofReporter.clear();
       setSfuUpstream(null);
       void route?.disconnect();
     }
@@ -932,8 +866,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
 
     function clearUpstreamState(clearMedia = false): void {
       qualityEvidenceReporter.reset();
-      codecProofReporter.clear();
-      activePeerProofSnapshot = null;
       const peer = peerRef.current;
       peer?.dispose();
       peerRef.current = null;
@@ -995,8 +927,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
               probe.snapshot = snapshot;
               provePendingPeer();
             } else if (active && peerRef.current === peer) {
-              activePeerProofSnapshot = snapshot;
-              offerCodecProof();
               observeActiveDecodedFrames(
                 "peer",
                 `${probe.parentPeerId}:${snapshot.connectionId}`,
@@ -1082,8 +1012,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
           },
           onUpdate: (snapshot) => {
             if (active) {
-              activePeerProofSnapshot = snapshot;
-              offerCodecProof();
               observeActiveDecodedFrames(
                 "peer",
                 `${snapshot.peerId}:${snapshot.connectionId}`,
@@ -1164,7 +1092,7 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
         }
         currentRouteRevision = nextRouteRevision;
         if (nextPeerAssisted && "routeAssignment" in message) {
-          activateProofRoute(
+          activateRouteIdentity(
             message.routeRevision,
             message.routeAssignment,
             message.connectionId,
@@ -1174,12 +1102,9 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
             message.routeAssignment.upstream,
           );
         } else {
-          codecProofReporter.clear();
           currentRouteAssignment = null;
           currentRouteConnectionId = null;
           pendingRouteConnection = null;
-          activePeerProofSnapshot = null;
-          activeSfuProofMetrics = null;
           setAssignedRoute(null);
           dispatchPresentation({
             type: "route",
@@ -1290,7 +1215,7 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
                   : samePeerUpstream || sameSfuUpstream
                     ? currentRouteConnectionId
                     : null;
-              activateProofRoute(
+              activateRouteIdentity(
                 message.revision,
                 message.assignment,
                 connectionId,
@@ -1305,32 +1230,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
         }
         return;
       }
-      if (message.type === "video-codec-prepare") {
-        const accepted =
-          peerAssisted &&
-          currentHostPaused &&
-          message.binding.kind === "peer" &&
-          (await ensureViewerRelay()?.prepareVideoCodec(
-            message.binding.childPeerId,
-            message.binding.connectionId,
-            message.generation,
-            message.videoCodec,
-          )) === true;
-        if (active && messageAuthority.owns(authorityToken)) {
-          signal.send({
-            type: "video-codec-prepared",
-            shareGeneration: message.shareGeneration,
-            generation: message.generation,
-            binding: message.binding,
-            accepted,
-          });
-        }
-        return;
-      }
-      if (message.type === "video-codec-proof-request") {
-        codecProofReporter.request(message);
-        return;
-      }
       if (message.type === "route-status") {
         dispatchPresentation({
           type: "route-status",
@@ -1458,7 +1357,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
         return;
       }
       if (message.type === "sharing-stopped") {
-        codecProofReporter.clear();
         currentRouteAssignment = null;
         currentRouteConnectionId = null;
         pendingRouteConnection = null;
@@ -1572,7 +1470,6 @@ export function ViewerPage({ roomId, viewerGrant }: ViewerPageProps) {
       active = false;
       currentPeerId = null;
       qualityEvidenceReporter.reset();
-      codecProofReporter.clear();
       clearRelayChildEvidence();
       sfuStandbyPrewarmer?.dispose();
       signal.stop();
diff --git a/src/client/pages/host-page-notices.ts b/src/client/pages/host-page-notices.ts
index 0a26102..e29255b 100644
--- a/src/client/pages/host-page-notices.ts
+++ b/src/client/pages/host-page-notices.ts
@@ -95,21 +95,8 @@ export function shouldPauseLocalPreview(
   return visibilityState !== "visible" || !hasFocus;
 }
 
-export const VIDEO_CODEC_TRANSITION_FAILED_NOTICE =
-  "视频编码切换已失效，请停止分享后重试";
-
-export function videoCodecLockNotice(
-  phase: string,
-  sharingPaused: boolean,
-  codecTransitionPhase: string | null = null,
-): string | null {
-  if (codecTransitionPhase === "failed") {
-    return VIDEO_CODEC_TRANSITION_FAILED_NOTICE;
-  }
-  if (phase === "starting") {
-    return "分享开始后，暂停分享即可切换视频编码";
-  }
-  return phase === "live" && !sharingPaused
-    ? "暂停分享后可切换视频编码"
+export function videoCodecLockNotice(phase: string): string | null {
+  return phase === "starting" || phase === "live"
+    ? "本次分享的视频编码已固定，停止分享后可更改"
     : null;
 }
diff --git a/src/client/sfu/publisher.ts b/src/client/sfu/publisher.ts
index 52114cf..51599c3 100644
--- a/src/client/sfu/publisher.ts
+++ b/src/client/sfu/publisher.ts
@@ -1101,11 +1101,10 @@ function videoPublishOptions(
   profile: QualityProfile,
 ): TrackPublishOptions {
   const highResolution = QUALITY_RESOLUTIONS[profile.resolution];
+  const videoCodec = profile.videoCodec ?? "vp8";
   return {
     backupCodec: false,
-    ...(!profile.videoCodec || profile.videoCodec === "automatic"
-      ? {}
-      : { videoCodec: profile.videoCodec }),
+    ...(videoCodec === "automatic" ? {} : { videoCodec }),
     simulcast: true,
     screenShareEncoding: {
       maxBitrate: profile.maxBitrate,
diff --git a/src/client/webrtc/host-peer.ts b/src/client/webrtc/host-peer.ts
index b863c84..0635825 100644
--- a/src/client/webrtc/host-peer.ts
+++ b/src/client/webrtc/host-peer.ts
@@ -1,8 +1,4 @@
-import type {
-  CodecTransitionGeneration,
-  IceConfig,
-  SignalPayload,
-} from "../../shared/protocol";
+import type { IceConfig, SignalPayload } from "../../shared/protocol";
 import { createOpaqueId } from "../lib/opaque-id";
 import {
   audioSenderParameterWarning,
@@ -39,39 +35,12 @@ interface HostPeerEvents {
   onUpdate: (snapshot: PeerSnapshot) => void;
 }
 
-interface CodecPreparationRequest {
-  generation: CodecTransitionGeneration;
-  videoCodec: QualityProfile["videoCodec"];
-  negotiationEpoch: number;
-  promise: Promise<boolean>;
-  resolve: (accepted: boolean) => void;
-  settled: boolean;
-}
-
-interface CodecAnswerWaiter {
-  request: CodecPreparationRequest;
-  epoch: number;
-  resolve: (accepted: boolean) => void;
-}
-
-type NegotiationAnswerOwner =
-  | {
-      kind: "ordinary";
-      epoch: number;
-    }
-  | {
-      kind: "codec";
-      epoch: number;
-      waiter: CodecAnswerWaiter;
-    };
-
 export class HostPeer {
   readonly connectionId: string;
 
   private readonly connection: RTCPeerConnection;
   private readonly pendingCandidates: SignalCandidate[] = [];
   private statsAccumulator = createStatsAccumulator();
-  private videoTransceiver: RTCRtpTransceiver | null = null;
   private videoSender: RTCRtpSender | null = null;
   private audioSender: RTCRtpSender | null = null;
   private statsTimer: number | null = null;
@@ -90,8 +59,6 @@ export class HostPeer {
   private profileRevision = 0;
   private negotiationEpoch = 0;
   private ordinaryAnswerEpoch: number | null = null;
-  private codecPreparation: CodecPreparationRequest | null = null;
-  private codecAnswerWaiter: CodecAnswerWaiter | null = null;
   private senderMutationTail: Promise<void> = Promise.resolve();
   private negotiationTail: Promise<void> = Promise.resolve();
   private snapshot: PeerSnapshot;
@@ -133,13 +100,7 @@ export class HostPeer {
       direction: "sendonly",
       streams: [this.stream],
     });
-    if (this.desiredProfile.videoCodec !== "automatic") {
-      applyVideoCodecPreference(
-        videoTransceiver,
-        this.desiredProfile.videoCodec,
-      );
-    }
-    this.videoTransceiver = videoTransceiver;
+    applyVideoCodecPreference(videoTransceiver, this.desiredProfile.videoCodec);
     this.videoSender = videoTransceiver.sender;
     this.audioSender = this.connection.addTransceiver(audioTrack ?? "audio", {
       direction: "sendonly",
@@ -271,65 +232,6 @@ export class HostPeer {
     });
   }
 
-  prepareVideoCodec(
-    generation: CodecTransitionGeneration,
-    videoCodec: QualityProfile["videoCodec"],
-  ): Promise<boolean> {
-    const current = this.codecPreparation;
-    if (
-      current?.generation === generation &&
-      current.videoCodec === videoCodec
-    ) {
-      return current.promise;
-    }
-    if (current) {
-      this.finishCodecPreparation(current, false);
-    }
-
-    let resolve!: (accepted: boolean) => void;
-    const promise = new Promise<boolean>((resolvePromise) => {
-      resolve = resolvePromise;
-    });
-    const request: CodecPreparationRequest = {
-      generation,
-      videoCodec,
-      negotiationEpoch: this.nextNegotiationEpoch(),
-      promise,
-      resolve,
-      settled: false,
-    };
-    this.codecPreparation = request;
-    void this.enqueueSenderMutation(() =>
-      this.runCodecPreparation(request),
-    ).then(
-      (accepted) => this.finishCodecPreparation(request, accepted),
-      () => this.finishCodecPreparation(request, false),
-    );
-    return promise;
-  }
-
-  cancelVideoCodecPreparation(): void {
-    const request = this.codecPreparation;
-    if (!request) {
-      return;
-    }
-    this.finishCodecPreparation(request, false);
-    if (this.disposed) {
-      return;
-    }
-    const epoch = this.nextNegotiationEpoch();
-    void this.enqueueNegotiation(async () => {
-      if (
-        this.disposed ||
-        epoch !== this.negotiationEpoch ||
-        this.codecPreparation
-      ) {
-        return;
-      }
-      await this.rollbackPendingLocalOffer();
-    });
-  }
-
   async acceptSignal(payload: SignalPayload): Promise<void> {
     if (this.disposed || payload.connectionId !== this.connectionId) {
       return;
@@ -352,34 +254,15 @@ export class HostPeer {
   }
 
   async restartIce(): Promise<boolean> {
-    while (!this.disposed) {
-      const codecPreparation = this.codecPreparation;
-      if (codecPreparation) {
-        await codecPreparation.promise;
-        continue;
+    return this.enqueueNegotiation(async () => {
+      if (
+        this.disposed ||
+        this.connection.signalingState !== "stable"
+      ) {
+        return false;
       }
-      const restarted = await this.enqueueNegotiation(async () => {
-        if (this.disposed) {
-          return false;
-        }
-        if (this.codecPreparation) {
-          return null;
-        }
-        if (this.connection.signalingState !== "stable") {
-          return false;
-        }
-        const accepted = await this.createOwnedOffer(
-          true,
-          this.nextNegotiationEpoch(),
-          null,
-        );
-        return !accepted && this.codecPreparation ? null : accepted;
-      });
-      if (restarted !== null) {
-        return restarted;
-      }
-    }
-    return false;
+      return this.createOwnedOffer(true, this.nextNegotiationEpoch());
+    });
   }
 
   isConnected(): boolean {
@@ -414,7 +297,6 @@ export class HostPeer {
       window.clearInterval(this.statsTimer);
       this.statsTimer = null;
     }
-    this.cancelVideoCodecPreparation();
     this.connection.close();
   }
 
@@ -457,24 +339,18 @@ export class HostPeer {
 
   private createOffer(restart: boolean): Promise<boolean> {
     return this.enqueueNegotiation(async () => {
-      if (this.disposed || this.codecPreparation) {
+      if (this.disposed) {
         return false;
       }
-      return this.createOwnedOffer(
-        restart,
-        this.nextNegotiationEpoch(),
-        null,
-      );
+      return this.createOwnedOffer(restart, this.nextNegotiationEpoch());
     });
   }
 
   private async createOwnedOffer(
     restart: boolean,
     epoch: number,
-    negotiationGeneration: CodecTransitionGeneration | null,
-    request: CodecPreparationRequest | null = null,
   ): Promise<boolean> {
-    if (!this.ownsLocalOffer(epoch, request)) {
+    if (!this.ownsLocalOffer(epoch)) {
       return false;
     }
     try {
@@ -482,24 +358,21 @@ export class HostPeer {
         this.connection.restartIce();
       }
       const offer = await this.connection.createOffer();
-      if (!this.ownsLocalOffer(epoch, request)) {
+      if (!this.ownsLocalOffer(epoch)) {
         return false;
       }
       await this.connection.setLocalDescription(offer);
       if (
-        !this.ownsLocalOffer(epoch, request) ||
+        !this.ownsLocalOffer(epoch) ||
         !this.connection.localDescription
       ) {
         return false;
       }
-      if (negotiationGeneration === null) {
-        this.ordinaryAnswerEpoch = epoch;
-      }
+      this.ordinaryAnswerEpoch = epoch;
       if (
         !this.events.sendSignal(this.peerId, {
           kind: "description",
           connectionId: this.connectionId,
-          negotiationGeneration,
           description: {
             type: "offer",
             sdp: this.connection.localDescription.sdp,
@@ -512,13 +385,10 @@ export class HostPeer {
       this.emit();
       return true;
     } catch (error) {
-      if (!this.ownsLocalOffer(epoch, request)) {
+      if (!this.ownsLocalOffer(epoch)) {
         return false;
       }
-      if (
-        negotiationGeneration === null &&
-        this.ordinaryAnswerEpoch === epoch
-      ) {
+      if (this.ordinaryAnswerEpoch === epoch) {
         this.ordinaryAnswerEpoch = null;
       }
       this.setError(error, restart ? "恢复连接失败" : "创建连接失败");
@@ -536,206 +406,46 @@ export class HostPeer {
   private async acceptAnswer(
     payload: Extract<SignalPayload, { kind: "description" }>,
   ): Promise<void> {
-    const owner = this.currentAnswerOwner(payload.negotiationGeneration);
-    if (!owner) {
+    const epoch = this.ordinaryAnswerEpoch;
+    if (epoch === null || !this.ownsAnswer(epoch)) {
       return;
     }
     try {
       await this.connection.setRemoteDescription(payload.description);
-      if (!this.ownsAnswer(owner)) {
+      if (!this.ownsAnswer(epoch)) {
         return;
       }
       await this.flushCandidates();
-      if (this.ownsAnswer(owner)) {
-        this.completeAnswer(owner, true);
+      if (this.ownsAnswer(epoch)) {
+        this.ordinaryAnswerEpoch = null;
       }
     } catch (error) {
-      if (!this.ownsAnswer(owner)) {
+      if (!this.ownsAnswer(epoch)) {
         return;
       }
-      this.completeAnswer(owner, false);
+      this.ordinaryAnswerEpoch = null;
       throw error;
     }
   }
 
-  private currentAnswerOwner(
-    generation: CodecTransitionGeneration | null,
-  ): NegotiationAnswerOwner | null {
-    if (generation === null) {
-      const epoch = this.ordinaryAnswerEpoch;
-      return epoch !== null && epoch === this.negotiationEpoch
-        ? { kind: "ordinary", epoch }
-        : null;
-    }
-    const waiter = this.codecAnswerWaiter;
-    return waiter &&
-      waiter.epoch === this.negotiationEpoch &&
-      waiter.request.generation === generation &&
-      this.ownsCodecPreparation(waiter.request)
-      ? { kind: "codec", epoch: waiter.epoch, waiter }
-      : null;
-  }
-
-  private ownsAnswer(owner: NegotiationAnswerOwner): boolean {
-    if (this.disposed || owner.epoch !== this.negotiationEpoch) {
-      return false;
-    }
-    return owner.kind === "ordinary"
-      ? this.ordinaryAnswerEpoch === owner.epoch
-      : this.codecAnswerWaiter === owner.waiter &&
-          this.ownsCodecPreparation(owner.waiter.request);
-  }
-
-  private completeAnswer(
-    owner: NegotiationAnswerOwner,
-    accepted: boolean,
-  ): void {
-    if (!this.ownsAnswer(owner)) {
-      return;
-    }
-    if (owner.kind === "ordinary") {
-      this.ordinaryAnswerEpoch = null;
-      return;
-    }
-    this.codecAnswerWaiter = null;
-    owner.waiter.resolve(accepted);
-  }
-
-  private settleCodecAnswer(
-    accepted: boolean,
-    generation?: CodecTransitionGeneration,
-    epoch?: number,
-  ): void {
-    const waiter = this.codecAnswerWaiter;
-    if (
-      (generation !== undefined &&
-        waiter?.request.generation !== generation) ||
-      (epoch !== undefined && waiter?.epoch !== epoch)
-    ) {
-      return;
-    }
-    this.codecAnswerWaiter = null;
-    waiter?.resolve(accepted);
-  }
-
-  private async runCodecPreparation(
-    request: CodecPreparationRequest,
-  ): Promise<boolean> {
-    const negotiation = await this.enqueueNegotiation(async () => {
-      const transceiver = this.videoTransceiver;
-      if (
-        !this.ownsCodecPreparation(request) ||
-        request.negotiationEpoch !== this.negotiationEpoch ||
-        !transceiver ||
-        !(await this.rollbackPendingLocalOffer()) ||
-        !this.ownsCodecPreparation(request) ||
-        request.negotiationEpoch !== this.negotiationEpoch ||
-        !applyVideoCodecPreference(transceiver, request.videoCodec)
-      ) {
-        return null;
-      }
-      const answer = new Promise<boolean>((resolve) => {
-        this.codecAnswerWaiter = {
-          request,
-          epoch: request.negotiationEpoch,
-          resolve,
-        };
-      });
-      if (
-        !(await this.createOwnedOffer(
-          false,
-          request.negotiationEpoch,
-          request.generation,
-          request,
-        ))
-      ) {
-        this.settleCodecAnswer(
-          false,
-          request.generation,
-          request.negotiationEpoch,
-        );
-        return null;
-      }
-      return { answer };
-    });
-    if (!negotiation) {
-      return false;
-    }
-    const accepted = await negotiation.answer;
-    if (!accepted || !this.ownsCodecPreparation(request)) {
-      return false;
-    }
-    this.desiredProfile = {
-      ...this.desiredProfile,
-      videoCodec: request.videoCodec,
-    };
-    this.appliedVideoProfile = this.appliedVideoProfile
-      ? { ...this.appliedVideoProfile, videoCodec: request.videoCodec }
-      : { ...this.desiredProfile };
-    return true;
-  }
-
-  private ownsLocalOffer(
-    epoch: number,
-    request: CodecPreparationRequest | null,
-  ): boolean {
+  private ownsAnswer(epoch: number): boolean {
     return (
       !this.disposed &&
       epoch === this.negotiationEpoch &&
-      (request === null ||
-        (request.negotiationEpoch === epoch &&
-          this.ownsCodecPreparation(request)))
+      this.ordinaryAnswerEpoch === epoch
     );
   }
 
+  private ownsLocalOffer(epoch: number): boolean {
+    return !this.disposed && epoch === this.negotiationEpoch;
+  }
+
   private nextNegotiationEpoch(): number {
     this.ordinaryAnswerEpoch = null;
     this.negotiationEpoch += 1;
     return this.negotiationEpoch;
   }
 
-  private ownsCodecPreparation(request: CodecPreparationRequest): boolean {
-    return (
-      !this.disposed &&
-      !request.settled &&
-      this.codecPreparation === request
-    );
-  }
-
-  private finishCodecPreparation(
-    request: CodecPreparationRequest,
-    accepted: boolean,
-  ): void {
-    if (request.settled) {
-      return;
-    }
-    request.settled = true;
-    if (this.codecAnswerWaiter?.request === request) {
-      const waiter = this.codecAnswerWaiter;
-      this.codecAnswerWaiter = null;
-      waiter.resolve(false);
-    }
-    if (this.codecPreparation === request) {
-      this.codecPreparation = null;
-    }
-    request.resolve(accepted);
-  }
-
-  private async rollbackPendingLocalOffer(): Promise<boolean> {
-    if (this.connection.signalingState === "stable") {
-      return true;
-    }
-    if (this.connection.signalingState !== "have-local-offer") {
-      return false;
-    }
-    try {
-      await this.connection.setLocalDescription({ type: "rollback" });
-      return (this.connection.signalingState as RTCSignalingState) === "stable";
-    } catch {
-      return false;
-    }
-  }
-
   private async updateStats(): Promise<void> {
     if (
       this.disposed ||
diff --git a/src/client/webrtc/video-codec-preference.ts b/src/client/webrtc/video-codec-preference.ts
index d2125ed..0de8500 100644
--- a/src/client/webrtc/video-codec-preference.ts
+++ b/src/client/webrtc/video-codec-preference.ts
@@ -11,7 +11,7 @@ export function applyVideoCodecPreference(
   transceiver: RTCRtpTransceiver,
   preference: VideoCodecPreference | undefined,
 ): boolean {
-  const resolvedPreference = preference ?? "automatic";
+  const resolvedPreference = preference ?? "vp8";
   if (typeof transceiver.setCodecPreferences !== "function") {
     return false;
   }
diff --git a/src/client/webrtc/viewer-peer.ts b/src/client/webrtc/viewer-peer.ts
index c1b0764..c42154a 100644
--- a/src/client/webrtc/viewer-peer.ts
+++ b/src/client/webrtc/viewer-peer.ts
@@ -1,8 +1,4 @@
-import type {
-  CodecTransitionGeneration,
-  IceConfig,
-  SignalPayload,
-} from "../../shared/protocol";
+import type { IceConfig, SignalPayload } from "../../shared/protocol";
 import {
   EMPTY_METRICS,
   type PeerSnapshot,
@@ -65,9 +61,6 @@ export class ViewerPeer {
   private currentIceConfig: PeerIceConfig;
   private snapshot: PeerSnapshot | null = null;
   private descriptionTail: Promise<void> = Promise.resolve();
-  private latestCodecNegotiationGeneration:
-    | CodecTransitionGeneration
-    | null = null;
 
   constructor(
     iceConfig: PeerIceConfig,
@@ -98,14 +91,6 @@ export class ViewerPeer {
       if (!connection) {
         return;
       }
-      const generation = payload.negotiationGeneration;
-      if (generation !== null) {
-        const latest = this.latestCodecNegotiationGeneration;
-        if (latest !== null && generation <= latest) {
-          return;
-        }
-        this.latestCodecNegotiationGeneration = generation;
-      }
       return this.enqueueDescription(() =>
         this.acceptDescription(parentPeerId, connection, payload),
       );
@@ -194,7 +179,6 @@ export class ViewerPeer {
     this.parentPeerId = parentPeerId;
     this.connectionId = connectionId;
     this.descriptionTail = Promise.resolve();
-    this.latestCodecNegotiationGeneration = null;
     this.remoteStream = new MediaStream();
     this.statsAccumulator = createStatsAccumulator();
 
@@ -285,22 +269,21 @@ export class ViewerPeer {
     payload: Extract<SignalPayload, { kind: "description" }>,
   ): Promise<void> {
     const connectionId = payload.connectionId;
-    const generation = payload.negotiationGeneration;
     try {
       await connection.setRemoteDescription(payload.description);
-      if (!this.ownsDescription(connection, connectionId, generation)) {
+      if (!this.isCurrentConnection(connection, connectionId)) {
         return;
       }
       await this.flushCandidates(connection, connectionId);
-      if (!this.ownsDescription(connection, connectionId, generation)) {
+      if (!this.isCurrentConnection(connection, connectionId)) {
         return;
       }
       const answer = preferScreenAudioStereo(await connection.createAnswer());
-      if (!this.ownsDescription(connection, connectionId, generation)) {
+      if (!this.isCurrentConnection(connection, connectionId)) {
         return;
       }
       await connection.setLocalDescription(answer);
-      if (!this.ownsDescription(connection, connectionId, generation)) {
+      if (!this.isCurrentConnection(connection, connectionId)) {
         return;
       }
       if (!connection.localDescription) {
@@ -309,7 +292,6 @@ export class ViewerPeer {
       if (!this.events.sendSignal(parentPeerId, {
         kind: "description",
         connectionId,
-        negotiationGeneration: generation,
         description: {
           type: "answer",
           sdp: connection.localDescription.sdp,
@@ -320,7 +302,7 @@ export class ViewerPeer {
       this.offerRecoveryAttempts = 0;
       this.scheduleInitialConnectionDeadline(connection, connectionId);
     } catch (error) {
-      if (!this.ownsDescription(connection, connectionId, generation)) {
+      if (!this.isCurrentConnection(connection, connectionId)) {
         return;
       }
       this.setError(error, "处理分享端信令失败");
@@ -361,18 +343,6 @@ export class ViewerPeer {
     }
   }
 
-  private ownsDescription(
-    connection: RTCPeerConnection,
-    connectionId: string,
-    generation: CodecTransitionGeneration | null,
-  ): boolean {
-    return (
-      this.isCurrentConnection(connection, connectionId) &&
-      (generation === null ||
-        this.latestCodecNegotiationGeneration === generation)
-    );
-  }
-
   private handleConnectionState(state: RTCPeerConnectionState): void {
     if (state === "connected") {
       this.clearDisconnectTimer();
diff --git a/src/client/webrtc/viewer-relay.ts b/src/client/webrtc/viewer-relay.ts
index 60c936f..b156df9 100644
--- a/src/client/webrtc/viewer-relay.ts
+++ b/src/client/webrtc/viewer-relay.ts
@@ -1,5 +1,4 @@
 import type {
-  CodecTransitionGeneration,
   IceConfig,
   PreparedRouteCandidate,
   SignalPayload,
@@ -193,24 +192,6 @@ export class ViewerRelay {
     return result.catch(() => false);
   }
 
-  prepareVideoCodec(
-    childPeerId: string,
-    connectionId: string,
-    generation: CodecTransitionGeneration,
-    videoCodec: QualityProfile["videoCodec"],
-  ): Promise<boolean> {
-    const peer = this.peers.get(childPeerId);
-    if (
-      this.disposed ||
-      !peer ||
-      peer.connectionId !== connectionId ||
-      !this.childPeerIds.includes(childPeerId)
-    ) {
-      return Promise.resolve(false);
-    }
-    return peer.prepareVideoCodec(generation, videoCodec);
-  }
-
   getSignalRouteRevision(
     fromPeerId: string,
     connectionId: string,
diff --git a/src/server/codec-transition.ts b/src/server/codec-transition.ts
deleted file mode 100644
index d2ff57e..0000000
--- a/src/server/codec-transition.ts
+++ /dev/null
@@ -1,1247 +0,0 @@
-import type {
-  ClientMessage,
-  CodecPreparationBinding,
-  CodecProofBinding,
-  CodecTransitionGeneration,
-  ResumeAttempt,
-  ServerMessage,
-  VideoCodecPreference,
-} from "../shared/protocol.js";
-import type {
-  CodecRouteSnapshot,
-  CodecRouteTarget,
-} from "./hybrid-media-router.js";
-
-const DEFAULT_CODEC_TRANSITION_TIMEOUT_MS = 20_000;
-
-type PreparedMessage = Extract<
-  ClientMessage,
-  { type: "video-codec-prepared" }
->;
-type ProofMessage = Extract<ClientMessage, { type: "video-codec-proof" }>;
-type ResultMessage = Extract<ServerMessage, { type: "video-codec-result" }>;
-type TransitionFailure = NonNullable<ResultMessage["failure"]>;
-type FrozenTarget = CodecRouteTarget;
-
-interface Preparation {
-  ownerSessionId: string;
-  binding: CodecPreparationBinding;
-}
-
-interface Transaction {
-  hostSessionId: string;
-  shareGeneration: string;
-  generation: CodecTransitionGeneration;
-  requested: VideoCodecPreference;
-  previous: VideoCodecPreference;
-  rollback: boolean;
-  requiresSfuReplacement: boolean;
-  sfuOperationPending: boolean;
-  phase:
-    | "initializing"
-    | "preparing"
-    | "prepared"
-    | "awaiting-source"
-    | "proving"
-    | "rollback-prepared"
-    | "failed";
-  failure: TransitionFailure | null;
-  targets: Map<string, FrozenTarget>;
-  pendingPreparations: Map<string, Preparation>;
-  pendingProofs: Set<string>;
-  proofRevision: number | null;
-  timer?: NodeJS.Timeout;
-}
-
-interface PendingResume {
-  hostSessionId: string;
-  shareGeneration: string;
-  codecGeneration: CodecTransitionGeneration | null;
-  resumeAttempt: ResumeAttempt;
-  deadlineAtMs: number;
-  timer: NodeJS.Timeout;
-}
-
-export interface CodecTransitionCoordinatorOptions {
-  snapshot: (roomId: string) => CodecRouteSnapshot | null;
-  sendToSession: (sessionId: string, message: ServerMessage) => void;
-  commitCodec: (roomId: string, videoCodec: VideoCodecPreference) => void;
-  authorizeResume: (
-    roomId: string,
-    hostSessionId: string,
-    shareGeneration: string,
-    codecGeneration: CodecTransitionGeneration | null,
-    resumeAttempt: ResumeAttempt,
-  ) => void;
-  confirmSourceEnabled: (
-    roomId: string,
-    hostSessionId: string,
-    shareGeneration: string,
-    codecGeneration: CodecTransitionGeneration | null,
-    resumeAttempt: ResumeAttempt,
-  ) => boolean;
-  restoreAuthoritativePause: (
-    roomId: string,
-    hostSessionId: string,
-    shareGeneration: string,
-    codecGeneration: CodecTransitionGeneration | null,
-    resumeAttempt: ResumeAttempt | null,
-  ) => void;
-  returnTargetsToRouteWait: (
-    roomId: string,
-    viewerPeerIds: readonly string[],
-  ) => void;
-  beginSfuReplacement: (input: {
-    roomId: string;
-    hostSessionId: string;
-    generation: CodecTransitionGeneration;
-    videoCodec: VideoCodecPreference;
-    timeoutMs: number;
-  }) => Promise<CodecRouteSnapshot | null>;
-  parkSfuReplacement: (
-    roomId: string,
-    generation: CodecTransitionGeneration,
-  ) => boolean;
-  beginSfuProof: (
-    roomId: string,
-    generation: CodecTransitionGeneration,
-    timeoutMs: number,
-  ) => boolean;
-  abortSfuReplacement: (
-    roomId: string,
-    generation: CodecTransitionGeneration,
-  ) => void;
-  releaseRoutePause: (roomId: string) => void;
-  timeoutMs?: number;
-  createGeneration?: () => CodecTransitionGeneration;
-  createResumeAttempt?: () => ResumeAttempt;
-  now?: () => number;
-}
-
-export class CodecTransitionCoordinator {
-  private readonly rooms = new Map<string, Transaction>();
-  private readonly timeoutMs: number;
-  private readonly createGeneration: () => CodecTransitionGeneration;
-  private readonly createResumeAttempt: () => ResumeAttempt;
-  private readonly now: () => number;
-  private latestGeneration = 0;
-  private latestResumeAttempt = 0;
-  private readonly pendingResumes = new Map<string, PendingResume>();
-  private readonly revalidatingRoomIds = new Set<string>();
-  private readonly deferredRevalidationRoomIds = new Set<string>();
-
-  constructor(private readonly options: CodecTransitionCoordinatorOptions) {
-    this.timeoutMs = options.timeoutMs ?? DEFAULT_CODEC_TRANSITION_TIMEOUT_MS;
-    if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0) {
-      throw new Error("Codec transition timeout must be a positive integer");
-    }
-    this.createGeneration =
-      options.createGeneration ?? (() => this.latestGeneration + 1);
-    this.createResumeAttempt =
-      options.createResumeAttempt ?? (() => this.latestResumeAttempt + 1);
-    this.now = options.now ?? Date.now;
-  }
-
-  start(input: {
-    roomId: string;
-    hostSessionId: string;
-    shareGeneration: string;
-    requested: VideoCodecPreference;
-    previous: VideoCodecPreference;
-  }): "started" | "committed" | "busy" | "unavailable" {
-    if (this.rooms.has(input.roomId)) {
-      return "busy";
-    }
-    const snapshot = this.options.snapshot(input.roomId);
-    if (!snapshot) {
-      return "unavailable";
-    }
-    if (snapshot.targets.length === 0) {
-      this.options.commitCodec(input.roomId, input.requested);
-      this.sendResult(input.hostSessionId, {
-        generation: this.allocateGeneration(),
-        videoCodec: input.requested,
-        status: "committed",
-        failure: null,
-      });
-      return "committed";
-    }
-    const transaction: Transaction = {
-      hostSessionId: input.hostSessionId,
-      shareGeneration: input.shareGeneration,
-      generation: this.allocateGeneration(),
-      requested: input.requested,
-      previous: input.previous,
-      rollback: false,
-      requiresSfuReplacement: snapshot.targets.some(isSfuTarget),
-      sfuOperationPending: false,
-      phase: "initializing",
-      failure: null,
-      targets: new Map(),
-      pendingPreparations: new Map(),
-      pendingProofs: new Set(),
-      proofRevision: null,
-    };
-    this.rooms.set(input.roomId, transaction);
-    this.beginTransactionPreparation(input.roomId, transaction, snapshot);
-    return "started";
-  }
-
-  prepared(
-    roomId: string,
-    senderSessionId: string,
-    message: PreparedMessage,
-  ): void {
-    let transaction = this.rooms.get(roomId);
-    if (!this.messageOwns(transaction, message)) {
-      return;
-    }
-    this.revalidate(roomId, transaction);
-    transaction = this.rooms.get(roomId);
-    if (!this.messageOwns(transaction, message)) {
-      return;
-    }
-    const key = preparationKey(message.binding);
-    const expected = transaction.pendingPreparations.get(key);
-    if (
-      transaction.phase !== "preparing" ||
-      !expected ||
-      expected.ownerSessionId !== senderSessionId ||
-      !samePreparationBinding(expected.binding, message.binding)
-    ) {
-      return;
-    }
-    if (!message.accepted) {
-      this.preparationFailed(roomId, transaction);
-      return;
-    }
-    transaction.pendingPreparations.delete(key);
-    if (transaction.pendingPreparations.size === 0) {
-      this.finishPreparation(roomId, transaction);
-    }
-  }
-
-  requestResume(input: {
-    roomId: string;
-    hostSessionId: string;
-    shareGeneration: string;
-  }): "normal" | "started-proof" | "busy" {
-    if (this.pendingResumes.has(input.roomId)) {
-      return "busy";
-    }
-    let transaction = this.rooms.get(input.roomId);
-    if (!transaction) {
-      this.beginResumeAttempt(input, null);
-      return "normal";
-    }
-    if (
-      transaction.hostSessionId !== input.hostSessionId ||
-      transaction.shareGeneration !== input.shareGeneration ||
-      (transaction.phase !== "prepared" &&
-        transaction.phase !== "rollback-prepared")
-    ) {
-      return "busy";
-    }
-    this.revalidate(input.roomId, transaction);
-    transaction = this.rooms.get(input.roomId);
-    if (
-      !transaction ||
-      transaction.hostSessionId !== input.hostSessionId ||
-      transaction.shareGeneration !== input.shareGeneration ||
-      (transaction.phase !== "prepared" &&
-        transaction.phase !== "rollback-prepared")
-    ) {
-      return "busy";
-    }
-    if (transaction.targets.size === 0) {
-      this.finishProof(input.roomId, transaction, false);
-      this.beginResumeAttempt(input, null);
-      return "started-proof";
-    }
-    transaction.phase = "awaiting-source";
-    transaction.proofRevision = null;
-    transaction.pendingProofs = new Set(transaction.targets.keys());
-    this.beginResumeAttempt(input, transaction.generation);
-    return "started-proof";
-  }
-
-  sourceEnabled(input: {
-    roomId: string;
-    hostSessionId: string;
-    shareGeneration: string;
-    codecGeneration: CodecTransitionGeneration | null;
-    resumeAttempt: ResumeAttempt;
-  }): boolean {
-    const pending = this.pendingResumes.get(input.roomId);
-    if (!sameResumeAttempt(pending, input)) {
-      return false;
-    }
-    if (pending.deadlineAtMs <= this.now()) {
-      this.resumeAttemptExpired(input.roomId, pending);
-      return false;
-    }
-
-    if (input.codecGeneration === null) {
-      if (
-        !this.options.confirmSourceEnabled(
-          input.roomId,
-          input.hostSessionId,
-          input.shareGeneration,
-          null,
-          input.resumeAttempt,
-        )
-      ) {
-        return false;
-      }
-      this.clearPendingResume(input.roomId, pending);
-      this.options.releaseRoutePause(input.roomId);
-      return true;
-    }
-
-    let transaction = this.rooms.get(input.roomId);
-    if (
-      !transaction ||
-      transaction.phase !== "awaiting-source" ||
-      transaction.generation !== input.codecGeneration
-    ) {
-      return false;
-    }
-    this.revalidate(input.roomId, transaction);
-    transaction = this.rooms.get(input.roomId);
-    const currentPending = this.pendingResumes.get(input.roomId);
-    if (
-      !transaction ||
-      transaction.phase !== "awaiting-source" ||
-      transaction.generation !== input.codecGeneration ||
-      !sameResumeAttempt(currentPending, input)
-    ) {
-      return false;
-    }
-    const remainingMs = currentPending.deadlineAtMs - this.now();
-    if (remainingMs <= 0) {
-      this.resumeAttemptExpired(input.roomId, currentPending);
-      return false;
-    }
-    if (
-      !this.options.confirmSourceEnabled(
-        input.roomId,
-        input.hostSessionId,
-        input.shareGeneration,
-        input.codecGeneration,
-        input.resumeAttempt,
-      )
-    ) {
-      return false;
-    }
-    if (transaction.targets.size === 0) {
-      this.finishProof(input.roomId, transaction);
-      return true;
-    }
-    if (
-      transaction.sfuOperationPending &&
-      !this.options.beginSfuProof(
-        input.roomId,
-        transaction.generation,
-        Math.max(1, Math.ceil(remainingMs)),
-      )
-    ) {
-      this.proofFailed(input.roomId, transaction);
-      return false;
-    }
-    transaction.phase = "proving";
-    transaction.proofRevision = null;
-    transaction.pendingProofs = new Set(transaction.targets.keys());
-    this.revalidate(input.roomId, transaction);
-    const proving = this.rooms.get(input.roomId);
-    if (proving === transaction && proving.phase === "proving") {
-      if (proving.targets.size === 0) {
-        this.finishProof(input.roomId, proving);
-      } else {
-        this.issueProofBatch(input.roomId, proving);
-      }
-    }
-    return true;
-  }
-
-  pause(input: {
-    roomId: string;
-    hostSessionId: string;
-    shareGeneration: string;
-  }): void {
-    const pending = this.pendingResumes.get(input.roomId);
-    if (
-      pending &&
-      (pending.hostSessionId !== input.hostSessionId ||
-        pending.shareGeneration !== input.shareGeneration)
-    ) {
-      return;
-    }
-    if (pending) {
-      this.clearPendingResume(input.roomId, pending);
-    }
-    const transaction = this.rooms.get(input.roomId);
-    if (
-      !transaction ||
-      transaction.hostSessionId !== input.hostSessionId ||
-      transaction.shareGeneration !== input.shareGeneration ||
-      (transaction.phase !== "awaiting-source" &&
-        transaction.phase !== "proving")
-    ) {
-      return;
-    }
-    transaction.pendingProofs.clear();
-    transaction.proofRevision = null;
-    if (transaction.sfuOperationPending) {
-      this.options.parkSfuReplacement(input.roomId, transaction.generation);
-    }
-    transaction.phase = transaction.rollback
-      ? "rollback-prepared"
-      : "prepared";
-  }
-
-  proof(roomId: string, senderSessionId: string, message: ProofMessage): void {
-    let transaction = this.rooms.get(roomId);
-    let pendingResume = this.pendingResumes.get(roomId);
-    if (
-      !this.messageOwns(transaction, message) ||
-      !pendingResume ||
-      pendingResume.codecGeneration !== message.generation ||
-      pendingResume.resumeAttempt !== message.resumeAttempt ||
-      transaction.phase !== "proving"
-    ) {
-      return;
-    }
-    this.revalidate(roomId, transaction);
-    transaction = this.rooms.get(roomId);
-    pendingResume = this.pendingResumes.get(roomId);
-    if (
-      !this.messageOwns(transaction, message) ||
-      !pendingResume ||
-      pendingResume.codecGeneration !== message.generation ||
-      pendingResume.resumeAttempt !== message.resumeAttempt ||
-      transaction.phase !== "proving" ||
-      transaction.proofRevision !== message.routeRevision
-    ) {
-      return;
-    }
-    const target = [...transaction.targets.values()].find(
-      (candidate) => candidate.viewerSessionId === senderSessionId,
-    );
-    if (
-      !target ||
-      !transaction.pendingProofs.has(target.viewerPeerId) ||
-      !target.proofReady ||
-      target.routeRevision !== message.routeRevision ||
-      !sameProofBinding(target.proofBinding, message.binding)
-    ) {
-      return;
-    }
-    const expected = expectedActualCodec(transaction);
-    if (expected && message.evidence.actualCodec !== expected) {
-      this.proofFailed(roomId, transaction);
-      return;
-    }
-    transaction.pendingProofs.delete(target.viewerPeerId);
-    if (transaction.pendingProofs.size === 0) {
-      this.finishProof(roomId, transaction);
-    }
-  }
-
-  participantChanged(roomId: string): void {
-    if (this.revalidatingRoomIds.has(roomId)) {
-      this.deferredRevalidationRoomIds.add(roomId);
-      return;
-    }
-    const transaction = this.rooms.get(roomId);
-    if (!transaction || transaction.phase === "failed") {
-      return;
-    }
-    this.revalidate(roomId, transaction);
-    const current = this.rooms.get(roomId);
-    if (current !== transaction) {
-      return;
-    }
-    if (
-      transaction.targets.size === 0 &&
-      transaction.phase !== "initializing" &&
-      transaction.phase !== "awaiting-source"
-    ) {
-      this.finishProof(
-        roomId,
-        transaction,
-        transaction.phase === "proving",
-      );
-      return;
-    }
-    if (
-      transaction.phase === "preparing" &&
-      transaction.pendingPreparations.size === 0
-    ) {
-      this.finishPreparation(roomId, transaction);
-    } else if (transaction.phase === "proving") {
-      this.issueProofBatch(roomId, transaction);
-      if (transaction.pendingProofs.size === 0) {
-        this.finishProof(roomId, transaction);
-      }
-    }
-  }
-
-  clearRoom(roomId: string): void {
-    this.deferredRevalidationRoomIds.delete(roomId);
-    this.clearPendingResume(roomId);
-    const transaction = this.rooms.get(roomId);
-    if (!transaction) {
-      return;
-    }
-    this.clearDeadline(transaction);
-    this.abortPendingSfuOperation(roomId, transaction);
-    this.rooms.delete(roomId);
-  }
-
-  blocksResume(roomId: string): boolean {
-    return this.rooms.has(roomId) || this.pendingResumes.has(roomId);
-  }
-
-  invalidateHostSession(roomId: string, nextHostSessionId?: string): void {
-    const pendingResume = this.pendingResumes.get(roomId);
-    this.clearPendingResume(roomId, pendingResume);
-    const transaction = this.rooms.get(roomId);
-    if (!transaction) {
-      if (pendingResume && nextHostSessionId) {
-        this.options.restoreAuthoritativePause(
-          roomId,
-          nextHostSessionId,
-          pendingResume.shareGeneration,
-          null,
-          null,
-        );
-      }
-      return;
-    }
-    this.clearDeadline(transaction);
-    this.abortPendingSfuOperation(roomId, transaction);
-    transaction.pendingPreparations.clear();
-    transaction.pendingProofs.clear();
-    transaction.proofRevision = null;
-    transaction.phase = "failed";
-    transaction.failure = "stale-binding";
-    if (nextHostSessionId) {
-      transaction.hostSessionId = nextHostSessionId;
-    }
-    this.options.restoreAuthoritativePause(
-      roomId,
-      transaction.hostSessionId,
-      transaction.shareGeneration,
-      transaction.generation,
-      null,
-    );
-    this.sendResult(transaction.hostSessionId, {
-      generation: transaction.generation,
-      videoCodec: transaction.previous,
-      status: "failed",
-      failure: "stale-binding",
-    });
-  }
-
-  close(): void {
-    for (const [roomId, transaction] of this.rooms) {
-      this.clearDeadline(transaction);
-      this.abortPendingSfuOperation(roomId, transaction);
-    }
-    for (const pending of this.pendingResumes.values()) {
-      clearTimeout(pending.timer);
-    }
-    this.pendingResumes.clear();
-    this.rooms.clear();
-    this.revalidatingRoomIds.clear();
-    this.deferredRevalidationRoomIds.clear();
-  }
-
-  private beginTransactionPreparation(
-    roomId: string,
-    transaction: Transaction,
-    snapshot: CodecRouteSnapshot,
-  ): void {
-    transaction.requiresSfuReplacement = snapshot.targets.some(isSfuTarget);
-    transaction.sfuOperationPending = false;
-    transaction.phase = transaction.requiresSfuReplacement
-      ? "initializing"
-      : "preparing";
-    transaction.pendingPreparations.clear();
-    transaction.pendingProofs.clear();
-    transaction.proofRevision = null;
-    this.armDeadline(roomId, transaction, () =>
-      this.preparationFailed(roomId, transaction),
-    );
-    if (!transaction.requiresSfuReplacement) {
-      transaction.targets = freezeTargets(snapshot);
-      this.sendPreparationRequests(roomId, transaction);
-      return;
-    }
-    const generation = transaction.generation;
-    transaction.sfuOperationPending = true;
-    const videoCodec = transaction.rollback
-      ? transaction.previous
-      : transaction.requested;
-    void this.options
-      .beginSfuReplacement({
-        roomId,
-        hostSessionId: transaction.hostSessionId,
-        generation,
-        videoCodec,
-        timeoutMs: this.timeoutMs,
-      })
-      .then((preparedSnapshot) => {
-        const current = this.rooms.get(roomId);
-        if (
-          current !== transaction ||
-          transaction.generation !== generation ||
-          transaction.phase !== "initializing"
-        ) {
-          this.options.abortSfuReplacement(roomId, generation);
-          return;
-        }
-        if (!preparedSnapshot || !preparedSnapshot.targets.some(isSfuTarget)) {
-          this.abortPendingSfuOperation(roomId, transaction);
-          const currentSnapshot = this.options.snapshot(roomId);
-          if (
-            !currentSnapshot ||
-            currentSnapshot.targets.some(isSfuTarget)
-          ) {
-            this.preparationFailed(roomId, transaction);
-            return;
-          }
-          transaction.requiresSfuReplacement = false;
-          transaction.targets = freezeTargets(currentSnapshot);
-          transaction.phase = "preparing";
-          this.sendPreparationRequests(roomId, transaction);
-          return;
-        }
-        transaction.targets = freezeTargets(preparedSnapshot);
-        transaction.phase = "preparing";
-        this.sendPreparationRequests(roomId, transaction);
-      })
-      .catch(() => {
-        const current = this.rooms.get(roomId);
-        if (
-          current === transaction &&
-          transaction.generation === generation &&
-          transaction.phase === "initializing"
-        ) {
-          this.preparationFailed(roomId, transaction);
-        } else {
-          this.options.abortSfuReplacement(roomId, generation);
-        }
-      });
-  }
-
-  private sendPreparationRequests(
-    roomId: string,
-    transaction: Transaction,
-  ): void {
-    transaction.pendingPreparations = preparationsFor(transaction.targets);
-    if (transaction.pendingPreparations.size === 0) {
-      if (transaction.targets.size === 0) {
-        this.finishProof(roomId, transaction, false);
-      } else {
-        this.finishPreparation(roomId, transaction);
-      }
-      return;
-    }
-    const videoCodec = transaction.rollback
-      ? transaction.previous
-      : transaction.requested;
-    for (const preparation of transaction.pendingPreparations.values()) {
-      if (preparation.binding.kind === "sfu") {
-        continue;
-      }
-      this.options.sendToSession(preparation.ownerSessionId, {
-        type: "video-codec-prepare",
-        shareGeneration: transaction.shareGeneration,
-        generation: transaction.generation,
-        videoCodec,
-        binding: preparation.binding,
-      });
-    }
-  }
-
-  private finishPreparation(roomId: string, transaction: Transaction): void {
-    if (
-      this.rooms.get(roomId) !== transaction ||
-      transaction.phase !== "preparing"
-    ) {
-      return;
-    }
-    if (
-      transaction.sfuOperationPending &&
-      !this.options.parkSfuReplacement(roomId, transaction.generation)
-    ) {
-      this.preparationFailed(roomId, transaction);
-      return;
-    }
-    this.clearDeadline(transaction);
-    transaction.phase = transaction.rollback ? "rollback-prepared" : "prepared";
-    this.sendResult(transaction.hostSessionId, {
-      generation: transaction.generation,
-      videoCodec: transaction.rollback
-        ? transaction.previous
-        : transaction.requested,
-      status: transaction.rollback ? "rollback-prepared" : "prepared",
-      failure: transaction.rollback ? transaction.failure : null,
-    });
-  }
-
-  private preparationFailed(roomId: string, transaction: Transaction): void {
-    if (this.rooms.get(roomId) !== transaction) {
-      return;
-    }
-    this.clearDeadline(transaction);
-    this.clearPendingResume(roomId);
-    this.abortPendingSfuOperation(roomId, transaction);
-    if (transaction.rollback) {
-      this.failClosed(roomId, transaction, "rollback-failed");
-      return;
-    }
-    transaction.failure = "preparation-failed";
-    transaction.rollback = true;
-    transaction.generation = this.allocateGeneration();
-    transaction.targets.clear();
-    this.beginTransactionPreparation(
-      roomId,
-      transaction,
-      this.options.snapshot(roomId) ?? { revision: 0, targets: [] },
-    );
-  }
-
-  private proofFailed(roomId: string, transaction: Transaction): void {
-    if (this.rooms.get(roomId) !== transaction) {
-      return;
-    }
-    this.clearDeadline(transaction);
-    const pendingResume = this.pendingResumes.get(roomId);
-    this.options.restoreAuthoritativePause(
-      roomId,
-      transaction.hostSessionId,
-      transaction.shareGeneration,
-      transaction.generation,
-      pendingResume?.resumeAttempt ?? null,
-    );
-    this.clearPendingResume(roomId, pendingResume);
-    this.abortPendingSfuOperation(roomId, transaction);
-    if (transaction.rollback) {
-      this.failClosed(roomId, transaction, "rollback-failed");
-      return;
-    }
-    transaction.failure = "proof-failed";
-    transaction.rollback = true;
-    transaction.generation = this.allocateGeneration();
-    transaction.targets.clear();
-    this.beginTransactionPreparation(
-      roomId,
-      transaction,
-      this.options.snapshot(roomId) ?? { revision: 0, targets: [] },
-    );
-  }
-
-  private finishProof(
-    roomId: string,
-    transaction: Transaction,
-    releaseRoutePause = true,
-  ): void {
-    if (this.rooms.get(roomId) !== transaction) {
-      return;
-    }
-    this.clearDeadline(transaction);
-    this.clearPendingResume(roomId);
-    const committed = transaction.rollback
-      ? transaction.previous
-      : transaction.requested;
-    this.options.commitCodec(roomId, committed);
-    this.rooms.delete(roomId);
-    this.sendResult(transaction.hostSessionId, {
-      generation: transaction.generation,
-      videoCodec: committed,
-      status: "committed",
-      failure: transaction.rollback ? transaction.failure : null,
-    });
-    if (releaseRoutePause) {
-      this.options.releaseRoutePause(roomId);
-    }
-  }
-
-  private failClosed(
-    roomId: string,
-    transaction: Transaction,
-    failure: TransitionFailure,
-  ): void {
-    if (this.rooms.get(roomId) !== transaction) {
-      return;
-    }
-    this.clearDeadline(transaction);
-    this.clearPendingResume(roomId);
-    this.abortPendingSfuOperation(roomId, transaction);
-    transaction.phase = "failed";
-    transaction.failure = failure;
-    transaction.pendingPreparations.clear();
-    transaction.pendingProofs.clear();
-    transaction.proofRevision = null;
-    this.sendResult(transaction.hostSessionId, {
-      generation: transaction.generation,
-      videoCodec: transaction.previous,
-      status: "failed",
-      failure,
-    });
-  }
-
-  private revalidate(roomId: string, transaction: Transaction): void {
-    if (this.revalidatingRoomIds.has(roomId)) {
-      this.deferredRevalidationRoomIds.add(roomId);
-      return;
-    }
-    this.revalidatingRoomIds.add(roomId);
-    try {
-      this.revalidateCurrentSnapshot(roomId, transaction);
-    } finally {
-      this.revalidatingRoomIds.delete(roomId);
-    }
-    if (this.deferredRevalidationRoomIds.delete(roomId)) {
-      this.participantChanged(roomId);
-    }
-  }
-
-  private revalidateCurrentSnapshot(
-    roomId: string,
-    transaction: Transaction,
-  ): void {
-    if (
-      transaction.phase === "initializing" ||
-      transaction.phase === "failed"
-    ) {
-      return;
-    }
-    const current = this.options.snapshot(roomId);
-    if (!current) {
-      this.invalidateAllTargets(roomId, transaction);
-      return;
-    }
-    let changed = false;
-    let lostSfuTarget = false;
-    const currentByViewer = new Map(
-      current.targets.map((target) => [target.viewerPeerId, target]),
-    );
-    const invalidatedViewerPeerIds: string[] = [];
-    for (const [viewerPeerId, frozen] of transaction.targets) {
-      const candidate = currentByViewer.get(viewerPeerId);
-      if (!candidate || !sameTarget(frozen, candidate)) {
-        transaction.targets.delete(viewerPeerId);
-        transaction.pendingProofs.delete(viewerPeerId);
-        invalidatedViewerPeerIds.push(viewerPeerId);
-        lostSfuTarget ||= isSfuTarget(frozen);
-        changed = true;
-        continue;
-      }
-      if (
-        frozen.routeRevision !== candidate.routeRevision ||
-        frozen.proofReady !== candidate.proofReady
-      ) {
-        frozen.routeRevision = candidate.routeRevision;
-        frozen.proofReady = candidate.proofReady;
-        changed = true;
-      }
-    }
-    if (
-      transaction.sfuOperationPending &&
-      [...transaction.targets.values()].some(
-        (target) => isSfuTarget(target) && target.proofReady,
-      )
-    ) {
-      transaction.sfuOperationPending = false;
-    }
-    if (lostSfuTarget && transaction.sfuOperationPending) {
-      this.abortPendingSfuOperation(roomId, transaction);
-      transaction.requiresSfuReplacement = false;
-    }
-    const pendingSfuSubtree = transaction.sfuOperationPending
-      ? pendingSfuSubtreeViewerPeerIds(transaction.targets)
-      : new Set<string>();
-    if (transaction.phase === "proving") {
-      for (const [viewerPeerId, target] of transaction.targets) {
-        if (target.proofReady || pendingSfuSubtree.has(viewerPeerId)) continue;
-        transaction.targets.delete(viewerPeerId);
-        transaction.pendingProofs.delete(viewerPeerId);
-        invalidatedViewerPeerIds.push(viewerPeerId);
-        changed = true;
-      }
-    }
-    if (transaction.phase === "preparing") {
-      const stillRequired = preparationsFor(transaction.targets);
-      for (const [key, preparation] of transaction.pendingPreparations) {
-        const currentPreparation = stillRequired.get(key);
-        if (
-          !currentPreparation ||
-          currentPreparation.ownerSessionId !== preparation.ownerSessionId
-        ) {
-          transaction.pendingPreparations.delete(key);
-        }
-      }
-    }
-    if (invalidatedViewerPeerIds.length > 0) {
-      this.options.returnTargetsToRouteWait(roomId, invalidatedViewerPeerIds);
-      this.refreshRetainedTargets(roomId, transaction);
-    }
-    if (transaction.phase === "proving" && changed) {
-      transaction.proofRevision = null;
-      transaction.pendingProofs = new Set(transaction.targets.keys());
-      this.issueProofBatch(roomId, transaction);
-    }
-  }
-
-  private invalidateAllTargets(
-    roomId: string,
-    transaction: Transaction,
-  ): void {
-    const invalidated = [...transaction.targets.keys()];
-    const hadSfu = [...transaction.targets.values()].some(isSfuTarget);
-    transaction.targets.clear();
-    transaction.pendingPreparations.clear();
-    transaction.pendingProofs.clear();
-    transaction.proofRevision = null;
-    if (invalidated.length > 0) {
-      this.options.returnTargetsToRouteWait(roomId, invalidated);
-    }
-    if (hadSfu && transaction.sfuOperationPending) {
-      this.abortPendingSfuOperation(roomId, transaction);
-      transaction.requiresSfuReplacement = false;
-    }
-  }
-
-  private refreshRetainedTargets(
-    roomId: string,
-    transaction: Transaction,
-  ): void {
-    const current = this.options.snapshot(roomId);
-    if (!current) {
-      return;
-    }
-    const currentByViewer = new Map(
-      current.targets.map((target) => [target.viewerPeerId, target]),
-    );
-    for (const [viewerPeerId, frozen] of transaction.targets) {
-      const candidate = currentByViewer.get(viewerPeerId);
-      if (candidate && sameTarget(frozen, candidate)) {
-        frozen.routeRevision = candidate.routeRevision;
-        frozen.proofReady = candidate.proofReady;
-      }
-    }
-  }
-
-  private issueProofBatch(roomId: string, transaction: Transaction): void {
-    const pendingResume = this.pendingResumes.get(roomId);
-    if (
-      transaction.phase !== "proving" ||
-      !pendingResume ||
-      pendingResume.hostSessionId !== transaction.hostSessionId ||
-      pendingResume.shareGeneration !== transaction.shareGeneration ||
-      pendingResume.codecGeneration !== transaction.generation ||
-      transaction.targets.size === 0 ||
-      [...transaction.targets.values()].some((target) => !target.proofReady)
-    ) {
-      return;
-    }
-    const revisions = new Set(
-      [...transaction.targets.values()].map((target) => target.routeRevision),
-    );
-    if (revisions.size !== 1) {
-      return;
-    }
-    const revision = revisions.values().next().value;
-    if (revision === undefined || transaction.proofRevision === revision) {
-      return;
-    }
-    transaction.proofRevision = revision;
-    transaction.pendingProofs = new Set(transaction.targets.keys());
-    const expectedCodec = expectedActualCodec(transaction);
-    for (const target of transaction.targets.values()) {
-      this.options.sendToSession(target.viewerSessionId, {
-        type: "video-codec-proof-request",
-        shareGeneration: transaction.shareGeneration,
-        generation: transaction.generation,
-        resumeAttempt: pendingResume.resumeAttempt,
-        routeRevision: target.routeRevision,
-        expectedCodec,
-        binding: target.proofBinding,
-      });
-    }
-  }
-
-  private abortPendingSfuOperation(
-    roomId: string,
-    transaction: Transaction,
-  ): void {
-    if (!transaction.sfuOperationPending) return;
-    transaction.sfuOperationPending = false;
-    this.options.abortSfuReplacement(roomId, transaction.generation);
-  }
-
-  private beginResumeAttempt(
-    input: {
-      roomId: string;
-      hostSessionId: string;
-      shareGeneration: string;
-    },
-    codecGeneration: CodecTransitionGeneration | null,
-  ): void {
-    const resumeAttempt = this.allocateResumeAttempt();
-    let pending!: PendingResume;
-    const timer = setTimeout(
-      () => this.resumeAttemptExpired(input.roomId, pending),
-      this.timeoutMs,
-    );
-    pending = {
-      hostSessionId: input.hostSessionId,
-      shareGeneration: input.shareGeneration,
-      codecGeneration,
-      resumeAttempt,
-      deadlineAtMs: this.now() + this.timeoutMs,
-      timer,
-    };
-    this.pendingResumes.set(input.roomId, pending);
-    this.options.authorizeResume(
-      input.roomId,
-      input.hostSessionId,
-      input.shareGeneration,
-      codecGeneration,
-      resumeAttempt,
-    );
-  }
-
-  private resumeAttemptExpired(roomId: string, pending: PendingResume): void {
-    if (this.pendingResumes.get(roomId) !== pending) {
-      return;
-    }
-    const transaction = this.rooms.get(roomId);
-    if (
-      transaction &&
-      pending.codecGeneration === transaction.generation &&
-      transaction.phase === "proving"
-    ) {
-      this.proofFailed(roomId, transaction);
-      return;
-    }
-    this.options.restoreAuthoritativePause(
-      roomId,
-      pending.hostSessionId,
-      pending.shareGeneration,
-      pending.codecGeneration,
-      pending.resumeAttempt,
-    );
-    this.clearPendingResume(roomId, pending);
-    if (
-      transaction &&
-      pending.codecGeneration === transaction.generation &&
-      transaction.phase === "awaiting-source"
-    ) {
-      transaction.pendingProofs.clear();
-      transaction.proofRevision = null;
-      transaction.phase = transaction.rollback
-        ? "rollback-prepared"
-        : "prepared";
-    }
-  }
-
-  private clearPendingResume(
-    roomId: string,
-    expected?: PendingResume,
-  ): void {
-    const pending = this.pendingResumes.get(roomId);
-    if (!pending || (expected && pending !== expected)) {
-      return;
-    }
-    clearTimeout(pending.timer);
-    this.pendingResumes.delete(roomId);
-  }
-
-  private allocateGeneration(): CodecTransitionGeneration {
-    const generation = this.createGeneration();
-    if (
-      !Number.isSafeInteger(generation) ||
-      generation <= this.latestGeneration
-    ) {
-      throw new Error("Codec transition generation must increase monotonically");
-    }
-    this.latestGeneration = generation;
-    return generation;
-  }
-
-  private allocateResumeAttempt(): ResumeAttempt {
-    const resumeAttempt = this.createResumeAttempt();
-    if (
-      !Number.isSafeInteger(resumeAttempt) ||
-      resumeAttempt <= this.latestResumeAttempt
-    ) {
-      throw new Error("Resume attempt must increase monotonically");
-    }
-    this.latestResumeAttempt = resumeAttempt;
-    return resumeAttempt;
-  }
-
-  private armDeadline(
-    roomId: string,
-    transaction: Transaction,
-    expire: () => void,
-  ): void {
-    this.clearDeadline(transaction);
-    transaction.timer = setTimeout(() => {
-      if (this.rooms.get(roomId) === transaction) {
-        transaction.timer = undefined;
-        expire();
-      }
-    }, this.timeoutMs);
-  }
-
-  private clearDeadline(transaction: Transaction): void {
-    if (transaction.timer) {
-      clearTimeout(transaction.timer);
-      transaction.timer = undefined;
-    }
-  }
-
-  private messageOwns(
-    transaction: Transaction | undefined,
-    message: {
-      shareGeneration: string;
-      generation: CodecTransitionGeneration;
-    },
-  ): transaction is Transaction {
-    return Boolean(
-      transaction &&
-        transaction.shareGeneration === message.shareGeneration &&
-        transaction.generation === message.generation,
-    );
-  }
-
-  private sendResult(
-    hostSessionId: string,
-    result: Omit<ResultMessage, "type">,
-  ): void {
-    this.options.sendToSession(hostSessionId, {
-      type: "video-codec-result",
-      ...result,
-    });
-  }
-}
-
-function freezeTargets(snapshot: CodecRouteSnapshot): Map<string, FrozenTarget> {
-  return new Map(
-    snapshot.targets.map((target) => [target.viewerPeerId, { ...target }]),
-  );
-}
-
-function preparationsFor(
-  targets: ReadonlyMap<string, FrozenTarget>,
-): Map<string, Preparation> {
-  const preparations = new Map<string, Preparation>();
-  for (const target of targets.values()) {
-    const key = preparationKey(target.preparationBinding);
-    preparations.set(key, {
-      ownerSessionId: target.preparationOwnerSessionId,
-      binding: target.preparationBinding,
-    });
-  }
-  return preparations;
-}
-
-function preparationKey(binding: CodecPreparationBinding): string {
-  return binding.kind === "peer"
-    ? `peer:${binding.childPeerId}:${binding.connectionId}`
-    : `sfu:${binding.publicationGeneration}`;
-}
-
-function samePreparationBinding(
-  left: CodecPreparationBinding,
-  right: CodecPreparationBinding,
-): boolean {
-  return preparationKey(left) === preparationKey(right);
-}
-
-function sameProofBinding(
-  left: CodecProofBinding,
-  right: CodecProofBinding,
-): boolean {
-  return left.kind === right.kind &&
-    left.connectionId === right.connectionId &&
-    (left.kind === "peer" ||
-      (right.kind === "sfu" &&
-        left.publicationGeneration === right.publicationGeneration));
-}
-
-function sameTarget(left: FrozenTarget, right: CodecRouteTarget): boolean {
-  return left.viewerSessionId === right.viewerSessionId &&
-    left.preparationOwnerSessionId === right.preparationOwnerSessionId &&
-    samePreparationBinding(left.preparationBinding, right.preparationBinding) &&
-    sameProofBinding(left.proofBinding, right.proofBinding);
-}
-
-function isSfuTarget(target: CodecRouteTarget): boolean {
-  return target.preparationBinding.kind === "sfu";
-}
-
-function pendingSfuSubtreeViewerPeerIds(
-  targets: ReadonlyMap<string, FrozenTarget>,
-): Set<string> {
-  const subtreeViewerPeerIds = new Set<string>();
-  const subtreeParentSessionIds = new Set<string>();
-  for (const target of targets.values()) {
-    if (!target.proofReady && isSfuTarget(target)) {
-      subtreeViewerPeerIds.add(target.viewerPeerId);
-      subtreeParentSessionIds.add(target.viewerSessionId);
-    }
-  }
-
-  let previousSize = -1;
-  while (subtreeViewerPeerIds.size !== previousSize) {
-    previousSize = subtreeViewerPeerIds.size;
-    for (const target of targets.values()) {
-      if (
-        target.preparationBinding.kind !== "peer" ||
-        subtreeViewerPeerIds.has(target.viewerPeerId) ||
-        !subtreeParentSessionIds.has(target.preparationOwnerSessionId)
-      ) {
-        continue;
-      }
-      subtreeViewerPeerIds.add(target.viewerPeerId);
-      subtreeParentSessionIds.add(target.viewerSessionId);
-    }
-  }
-  return subtreeViewerPeerIds;
-}
-
-function explicitCodec(
-  preference: VideoCodecPreference,
-): "h264" | "vp8" | null {
-  return preference === "automatic" ? null : preference;
-}
-
-function expectedActualCodec(
-  transaction: Pick<Transaction, "requested" | "rollback">,
-): "h264" | "vp8" | null {
-  return transaction.rollback ? null : explicitCodec(transaction.requested);
-}
-
-function sameResumeAttempt(
-  pending: PendingResume | undefined,
-  candidate: {
-    hostSessionId: string;
-    shareGeneration: string;
-    codecGeneration: CodecTransitionGeneration | null;
-    resumeAttempt: ResumeAttempt;
-  },
-): pending is PendingResume {
-  return Boolean(
-    pending &&
-      pending.hostSessionId === candidate.hostSessionId &&
-      pending.shareGeneration === candidate.shareGeneration &&
-      pending.codecGeneration === candidate.codecGeneration &&
-      pending.resumeAttempt === candidate.resumeAttempt,
-  );
-}
diff --git a/src/server/hybrid-media-router.ts b/src/server/hybrid-media-router.ts
index ed621e8..0d120f1 100644
--- a/src/server/hybrid-media-router.ts
+++ b/src/server/hybrid-media-router.ts
@@ -2,16 +2,12 @@ import { randomBytes } from "node:crypto";
 
 import type {
   ClientMessage,
-  CodecPreparationBinding,
-  CodecProofBinding,
-  CodecTransitionGeneration,
   MediaAssignment,
   MediaRouteUpstream,
   ParticipantRouteAssignment,
   PreparedRouteCandidate,
   Role,
   ServerMessage,
-  VideoCodecPreference,
 } from "../shared/protocol.js";
 import { assertEndpointMediaCopyCapacity } from "../shared/media-copy-accounting.js";
 import type { SfuTokenIssuer } from "./livekit-token.js";
@@ -21,8 +17,6 @@ import {
   type CandidatePlan,
   type CandidateReservation,
   type CandidateTuple,
-  type CodecOperationGuard,
-  type EdgeGuard,
   type OperationSnapshot,
   type RouteSnapshot,
 } from "./room-route-controller.js";
@@ -85,15 +79,6 @@ interface RoomRuntime {
   pump?: Promise<void>;
   deadlineTimer?: NodeJS.Timeout;
   refreshKeys: Set<string>;
-  codecOperation?: CodecOperationRuntime;
-  codecDrainBarrierKey?: string;
-}
-
-interface CodecOperationRuntime {
-  generation: CodecTransitionGeneration;
-  guard: CodecOperationGuard;
-  drainBeforePreparationKey?: string;
-  resolvePreparation?: (snapshot: CodecRouteSnapshot | null) => void;
 }
 
 interface PreparedCandidate {
@@ -106,10 +91,6 @@ interface PreparedCandidate {
   viewerSfuConfig?: Extract<ServerMessage, { type: "sfu-config" }>;
 }
 
-type ResourceWaiter =
-  | { kind: "admission" }
-  | { kind: "drain"; drainKey: string };
-
 type PrepareResult =
   | {
       kind: "denied";
@@ -161,24 +142,9 @@ export interface AuthenticatedRouteParticipant {
   sessionId: string;
 }
 
-export interface CodecRouteTarget {
-  viewerPeerId: string;
-  viewerSessionId: string;
-  preparationOwnerSessionId: string;
-  preparationBinding: CodecPreparationBinding;
-  proofBinding: CodecProofBinding;
-  routeRevision: number;
-  proofReady: boolean;
-}
-
-export interface CodecRouteSnapshot {
-  revision: number;
-  targets: readonly CodecRouteTarget[];
-}
-
 export class HybridMediaRouter {
   private readonly rooms = new Map<string, RoomRuntime>();
-  private readonly resourceWaiters = new Map<string, ResourceWaiter>();
+  private readonly resourceWaiters = new Set<string>();
   private readonly sfuDrainTasks = new Map<string, SfuDrainTask>();
   private readonly hostOfflineChecks = new Map<string, HostOfflineCheck>();
   private readonly now: () => number;
@@ -312,311 +278,6 @@ export class HybridMediaRouter {
       : { kind: "none" };
   }
 
-  codecRouteSnapshot(roomId: string): CodecRouteSnapshot | null {
-    const room = this.rooms.get(roomId);
-    const snapshot = room?.controller?.snapshot();
-    if (!room || !snapshot) {
-      return null;
-    }
-    const targets: CodecRouteTarget[] = [];
-    for (const [viewerPeerId, edge] of snapshot.upstreamByViewer) {
-      if (!edge.usable || !edge.physicalActive) {
-        continue;
-      }
-      const viewer = this.options.roomStore.getConnectedViewer(
-        roomId,
-        viewerPeerId,
-      );
-      if (viewer?.sessionId !== edge.childSessionId) {
-        continue;
-      }
-      const pathIsPhysical = this.pathIsPhysical(
-        roomId,
-        snapshot,
-        viewerPeerId,
-      );
-      if (edge.kind === "peer") {
-        const parent = this.connectedPeer(roomId, edge.parentPeerId);
-        if (parent?.sessionId !== edge.parentSessionId) {
-          continue;
-        }
-        targets.push({
-          viewerPeerId,
-          viewerSessionId: edge.childSessionId,
-          preparationOwnerSessionId: edge.parentSessionId,
-          preparationBinding: {
-            kind: "peer",
-            childPeerId: viewerPeerId,
-            connectionId: edge.connectionId,
-          },
-          proofBinding: {
-            kind: "peer",
-            connectionId: edge.connectionId,
-          },
-          routeRevision: snapshot.revision,
-          proofReady: pathIsPhysical,
-        });
-        continue;
-      }
-      const publication = snapshot.hostPublication;
-      const host = this.options.roomStore.getConnectedHost(roomId);
-      if (
-        pathIsPhysical &&
-        publication?.usable &&
-        publication.physicalActive &&
-        publication.generation === edge.publicationGeneration &&
-        host?.sessionId === publication.hostSessionId
-      ) {
-        targets.push({
-          viewerPeerId,
-          viewerSessionId: edge.childSessionId,
-          preparationOwnerSessionId: publication.hostSessionId,
-          preparationBinding: {
-            kind: "sfu",
-            publicationGeneration: edge.publicationGeneration,
-          },
-          proofBinding: {
-            kind: "sfu",
-            connectionId: edge.connectionId,
-            publicationGeneration: edge.publicationGeneration,
-          },
-          routeRevision: snapshot.revision,
-          proofReady: true,
-        });
-      }
-    }
-    const operation = snapshot.operation;
-    const current = operation?.current;
-    if (
-      operation?.owner.kind === "codec" &&
-      current?.tuple.kind === "sfu"
-    ) {
-      const host = this.options.roomStore.getConnectedHost(roomId);
-      const viewer = this.options.roomStore.getConnectedViewer(
-        roomId,
-        operation.childPeerId,
-      );
-      if (
-        host?.sessionId === operation.owner.hostSessionId &&
-        viewer?.sessionId === operation.childSessionId
-      ) {
-          const target: CodecRouteTarget = {
-            viewerPeerId: operation.childPeerId,
-            viewerSessionId: operation.childSessionId,
-            preparationOwnerSessionId: host.sessionId,
-            preparationBinding: {
-              kind: "sfu",
-              publicationGeneration: operation.owner.publicationGeneration,
-            },
-            proofBinding: {
-              kind: "sfu",
-              connectionId: operation.owner.connectionId,
-              publicationGeneration: operation.owner.publicationGeneration,
-            },
-            routeRevision: current.revision,
-            proofReady: false,
-          };
-          const existingIndex = targets.findIndex(
-            (candidate) => candidate.viewerPeerId === operation.childPeerId,
-          );
-          if (existingIndex === -1) targets.push(target);
-          else targets[existingIndex] = target;
-      }
-    }
-    return { revision: snapshot.revision, targets };
-  }
-
-  beginCodecSfuReplacement(input: {
-    roomId: string;
-    hostSessionId: string;
-    generation: CodecTransitionGeneration;
-    videoCodec: VideoCodecPreference;
-    timeoutMs: number;
-  }): Promise<CodecRouteSnapshot | null> {
-    const room = this.rooms.get(input.roomId);
-    const controller = room?.controller;
-    const snapshot = controller?.snapshot();
-    if (
-      !room ||
-      !controller ||
-      !snapshot ||
-      room.codecOperation ||
-      !this.options.sfuFallback
-    ) {
-      return Promise.resolve(null);
-    }
-    const nowMs = this.now();
-    const publicationGeneration = opaqueId();
-    const connectionId = opaqueId();
-    const publicationConnectionId = opaqueId();
-    const begun = controller.beginCodecSfuPublication({
-      routeRevision: snapshot.revision,
-      hostSessionId: input.hostSessionId,
-      codecGeneration: input.generation,
-      videoCodec: input.videoCodec,
-      publicationGeneration,
-      connectionId,
-      publicationConnectionId,
-      nowMs,
-      deadlineAtMs: nowMs + input.timeoutMs,
-    });
-    if (!begun.accepted || !begun.guard) {
-      this.releaseResources(begun.released);
-      return Promise.resolve(null);
-    }
-    let resolvePreparation!: (snapshot: CodecRouteSnapshot | null) => void;
-    const preparation = new Promise<CodecRouteSnapshot | null>((resolve) => {
-      resolvePreparation = resolve;
-    });
-    const carriedDrainBarrierKey = room.codecDrainBarrierKey;
-    const drainBeforePreparationKey =
-      carriedDrainBarrierKey ??
-      (snapshot.hostPublication?.resource.kind === "sfu-publication"
-        ? managedSfuRoomName(snapshot.hostPublication.resource.fence)
-        : undefined);
-    room.codecDrainBarrierKey = undefined;
-    room.codecOperation = {
-      generation: input.generation,
-      guard: begun.guard,
-      ...(drainBeforePreparationKey ? { drainBeforePreparationKey } : {}),
-      resolvePreparation,
-    };
-    this.releaseResources(begun.released);
-    if (controller.snapshot().revision !== snapshot.revision) {
-      this.broadcastActive(input.roomId, room);
-    }
-    this.requestPump(input.roomId);
-    return preparation;
-  }
-
-  parkCodecSfuReplacement(
-    roomId: string,
-    generation: CodecTransitionGeneration,
-  ): boolean {
-    const room = this.rooms.get(roomId);
-    const runtime = room?.codecOperation;
-    const controller = room?.controller;
-    const operation = controller?.snapshot().operation;
-    if (
-      !room ||
-      !runtime ||
-      runtime.generation !== generation ||
-      !controller ||
-      operation?.owner.kind !== "codec"
-    ) {
-      return false;
-    }
-    const expectedPhase = operation.owner.phase;
-    if (expectedPhase !== "preparing" && expectedPhase !== "proving") {
-      return expectedPhase === "prepared";
-    }
-    const parked = controller.transitionCodecOperation({
-      guard: runtime.guard,
-      expectedPhase,
-      phase: "prepared",
-    });
-    this.releaseResources(parked.released);
-    this.clearDeadline(room);
-    return parked.accepted;
-  }
-
-  beginCodecSfuProof(
-    roomId: string,
-    generation: CodecTransitionGeneration,
-    timeoutMs: number,
-  ): boolean {
-    const room = this.rooms.get(roomId);
-    const runtime = room?.codecOperation;
-    const controller = room?.controller;
-    if (!room || !runtime || runtime.generation !== generation || !controller) {
-      return false;
-    }
-    const nowMs = this.now();
-    const proving = controller.transitionCodecOperation({
-      guard: runtime.guard,
-      expectedPhase: "prepared",
-      phase: "proving",
-      nowMs,
-      deadlineAtMs: nowMs + timeoutMs,
-    });
-    this.releaseResources(proving.released);
-    this.clearDeadline(room);
-    return proving.accepted;
-  }
-
-  abortCodecSfuReplacement(
-    roomId: string,
-    generation: CodecTransitionGeneration,
-  ): void {
-    const room = this.rooms.get(roomId);
-    const runtime = room?.codecOperation;
-    const controller = room?.controller;
-    if (!room || !runtime || runtime.generation !== generation || !controller) {
-      return;
-    }
-    const before = controller.snapshot().revision;
-    const aborted = controller.abortCodecOperation(runtime.guard, this.now());
-    this.releaseResources(aborted.released);
-    this.carryCodecDrainBarrier(room);
-    this.resourceWaiters.delete(roomId);
-    this.settleCodecPreparation(room, null);
-    room.codecOperation = undefined;
-    this.clearDeadline(room);
-    if (controller.snapshot().revision !== before) {
-      this.broadcastActive(roomId, room);
-    }
-  }
-
-  routeWaitInvalidCodecTargets(
-    roomId: string,
-    viewerPeerIds: readonly string[],
-  ): number | null {
-    const room = this.rooms.get(roomId);
-    const controller = room?.controller;
-    const snapshot = controller?.snapshot();
-    if (!room || !controller || !snapshot) return null;
-
-    const guards: EdgeGuard[] = [];
-    for (const viewerPeerId of new Set(viewerPeerIds)) {
-      const viewer = this.options.roomStore.getConnectedViewer(
-        roomId,
-        viewerPeerId,
-      );
-      const edge = snapshot.upstreamByViewer.get(viewerPeerId);
-      if (
-        !viewer ||
-        !edge?.physicalActive ||
-        edge.childSessionId !== viewer.sessionId
-      ) {
-        continue;
-      }
-      guards.push({
-        childPeerId: viewerPeerId,
-        childSessionId: viewer.sessionId,
-        routeRevision: snapshot.revision,
-        connectionId: edge.connectionId,
-        ...(edge.kind === "peer"
-          ? { parentSessionId: edge.parentSessionId }
-          : {}),
-      });
-    }
-    if (guards.length === 0) return snapshot.revision;
-
-    const retired = controller.retireCommittedTransportsForRouteWait(
-      guards,
-      this.now(),
-    );
-    if (!retired.accepted) {
-      throw new Error("Codec route targets could not enter route-wait");
-    }
-    this.releaseResources(retired.released);
-    if (retired.activeRevision !== snapshot.revision) {
-      this.broadcastActive(roomId, room);
-    }
-    this.requestPump(roomId);
-    return retired.activeRevision;
-  }
-
   viewerSfuMediaStateIsCurrent(
     roomId: string,
     viewerPeerId: string,
@@ -748,10 +409,6 @@ export class HybridMediaRouter {
       return;
     }
     const before = controller.snapshot().revision;
-    const codecGeneration =
-      operation.owner.kind === "codec"
-        ? operation.owner.codecGeneration
-        : undefined;
     const settled = controller.candidateReady(
       {
         childPeerId: participant.peerId,
@@ -770,13 +427,6 @@ export class HybridMediaRouter {
         participant.peerId,
         current.connectionId,
       );
-      if (
-        codecGeneration !== undefined &&
-        room.codecOperation?.generation === codecGeneration
-      ) {
-        this.settleCodecPreparation(room, null);
-        room.codecOperation = undefined;
-      }
     }
     if (controller.snapshot().revision !== before) this.broadcastActive(participant.roomId, room);
     if (settled.exhausted) {
@@ -845,9 +495,7 @@ export class HybridMediaRouter {
         participant.role === "host" &&
         participant.peerId === room.hostPeerId &&
         this.options.roomStore.getConnectedHost(participant.roomId)
-          ?.sessionId === participant.sessionId &&
-        (operation.owner.kind !== "codec" ||
-          operation.owner.hostSessionId === participant.sessionId);
+          ?.sessionId === participant.sessionId;
       if (!ownsChild && !ownsParent && !ownsPublication) return;
       if (message.connectionId && message.connectionId !== current.connectionId) return;
       const before = snapshot.revision;
@@ -1021,10 +669,6 @@ export class HybridMediaRouter {
         if (room.requested && !this.closing) this.requestPump(roomId);
       }
     })().catch(() => {
-      const generation = room.codecOperation?.generation;
-      if (generation !== undefined) {
-        this.abortCodecSfuReplacement(roomId, generation);
-      }
       console.error("Media route reconciliation failed");
       this.sendRoomError(roomId, "SERVER_ERROR", "Media routing failed");
     });
@@ -1050,20 +694,11 @@ export class HybridMediaRouter {
       if (!operation) {
         this.clearDeadline(room);
         this.resourceWaiters.delete(roomId);
-        if (room.codecOperation) {
-          this.settleCodecPreparation(room, null);
-          this.carryCodecDrainBarrier(room);
-          room.codecOperation = undefined;
-        }
         return;
       }
       if (operation.current) {
         this.resourceWaiters.delete(roomId);
-        if (operation.owner.kind === "route") {
-          this.scheduleDeadline(roomId, room, operation);
-        } else {
-          this.clearDeadline(room);
-        }
+        this.scheduleDeadline(roomId, room, operation);
         return;
       }
       const plan = operation.candidates[operation.cursor];
@@ -1071,23 +706,9 @@ export class HybridMediaRouter {
         this.resourceWaiters.delete(roomId);
         return;
       }
-      if (operation.owner.kind === "codec") {
-        const runtime = room.codecOperation;
-        const drainKey = runtime?.drainBeforePreparationKey;
-        if (
-          runtime?.generation === operation.owner.codecGeneration &&
-          drainKey &&
-          this.sfuDrainTasks.has(drainKey)
-        ) {
-          this.resourceWaiters.set(roomId, { kind: "drain", drainKey });
-          this.clearDeadline(room);
-          return;
-        }
-        if (runtime) runtime.drainBeforePreparationKey = undefined;
-      }
       const guard = cursorGuard(operation, plan);
       if (plan.tuple.kind === "sfu") {
-        this.resourceWaiters.set(roomId, { kind: "admission" });
+        this.resourceWaiters.add(roomId);
       } else {
         this.resourceWaiters.delete(roomId);
       }
@@ -1103,18 +724,6 @@ export class HybridMediaRouter {
         if (preparation.rejectionBucket !== "sfu-admission") {
           this.resourceWaiters.delete(roomId);
         }
-        if (operation.owner.kind === "codec") {
-          if (preparation.rejectionBucket === "sfu-admission") {
-            this.resourceWaiters.set(roomId, { kind: "admission" });
-            this.clearDeadline(room);
-            return;
-          }
-          this.abortCodecSfuReplacement(
-            roomId,
-            operation.owner.codecGeneration,
-          );
-          return;
-        }
         if (preparation.rejectionBucket === "sfu-admission") {
           if (
             !controller.noteCurrentCandidateRejection(
@@ -1124,7 +733,7 @@ export class HybridMediaRouter {
           ) {
             continue;
           }
-          this.resourceWaiters.set(roomId, { kind: "admission" });
+          this.resourceWaiters.add(roomId);
           this.sendViewerRouteStatus(roomId, operation.childPeerId, {
             type: "route-status",
             revision: operation.baseRevision,
@@ -1152,10 +761,7 @@ export class HybridMediaRouter {
       }
       this.resourceWaiters.delete(roomId);
       let currentOperation = controller.snapshot().operation;
-      if (
-        operation.owner.kind === "route" &&
-        plan.endpointTransition.kind === "bounded-gap"
-      ) {
+      if (plan.endpointTransition.kind === "bounded-gap") {
         const beforeGap = controller.snapshot().revision;
         const gap = controller.retireCurrentCandidateProducer(guard, this.now());
         this.releaseResources(gap.released);
@@ -1190,13 +796,6 @@ export class HybridMediaRouter {
       });
       this.releaseResources(begun.released);
       if (!begun.accepted || !begun.operation?.current) {
-        if (operation.owner.kind === "codec") {
-          this.abortCodecSfuReplacement(
-            roomId,
-            operation.owner.codecGeneration,
-          );
-          return;
-        }
         if (begun.exhausted) {
         this.sendViewerRouteStatus(roomId, operation.childPeerId, {
           type: "route-status",
@@ -1213,15 +812,7 @@ export class HybridMediaRouter {
         begun.operation,
         preparation.prepared,
       );
-      if (begun.operation.owner.kind === "codec") {
-        this.clearDeadline(room);
-        this.settleCodecPreparation(
-          room,
-          this.codecRouteSnapshot(roomId),
-        );
-      } else {
-        this.scheduleDeadline(roomId, room, begun.operation);
-      }
+      this.scheduleDeadline(roomId, room, begun.operation);
       return;
     }
   }
@@ -1239,10 +830,7 @@ export class HybridMediaRouter {
     if (!child || child.sessionId !== operation.childSessionId || !shareGeneration) {
       return { kind: "denied", rejectionBucket: "stale" };
     }
-    const connectionId =
-      operation.owner.kind === "codec"
-        ? operation.owner.connectionId
-        : opaqueId();
+    const connectionId = opaqueId();
     const overlap =
       plan.endpointTransition.kind === "overlap"
         ? overlapResource(plan.endpointTransition.producerPeerId)
@@ -1262,9 +850,7 @@ export class HybridMediaRouter {
     if (
       !fallback ||
       !host ||
-      host.peerId !== room.hostPeerId ||
-      (operation.owner.kind === "codec" &&
-        host.sessionId !== operation.owner.hostSessionId)
+      host.peerId !== room.hostPeerId
     ) {
       return { kind: "denied", rejectionBucket: "stale" };
     }
@@ -1333,13 +919,6 @@ export class HybridMediaRouter {
       shareGeneration,
       host,
       overlap,
-      operation.owner.kind === "codec"
-        ? {
-            publicationGeneration: operation.owner.publicationGeneration,
-            publicationConnectionId:
-              operation.owner.publicationConnectionId,
-          }
-        : undefined,
     );
   }
 
@@ -1351,14 +930,9 @@ export class HybridMediaRouter {
     shareGeneration: string,
     host: { peerId: string; sessionId: string },
     overlap?: OverlapRouteResource,
-    codecIdentity?: {
-      publicationGeneration: string;
-      publicationConnectionId: string;
-    },
   ): Promise<PrepareResult> {
     const fallback = this.options.sfuFallback!;
-    const publicationGeneration =
-      codecIdentity?.publicationGeneration ?? opaqueId();
+    const publicationGeneration = opaqueId();
     const publicationFence: SfuResourceFence = {
       roomId,
       shareGeneration,
@@ -1377,8 +951,7 @@ export class HybridMediaRouter {
       return { kind: "denied", rejectionBucket: "sfu-admission" };
     }
     const subscription = subscriptionResource(subscriptionFence);
-    const publicationConnectionId =
-      codecIdentity?.publicationConnectionId ?? publicationGeneration;
+    const publicationConnectionId = publicationGeneration;
     const publication = publicationResource(publicationFence);
     try {
       await fallback.roomControl.createRoom(publicationFence);
@@ -1475,9 +1048,7 @@ export class HybridMediaRouter {
     if (
       prepared.hostSfuConfig &&
       host &&
-      host.sessionId === prepared.hostSessionId &&
-      (operation.owner.kind !== "codec" ||
-        host.sessionId === operation.owner.hostSessionId)
+      host.sessionId === prepared.hostSessionId
     ) {
       this.options.sendToSession(host.sessionId, {
         type: "route-update",
@@ -1723,12 +1294,6 @@ export class HybridMediaRouter {
       return;
     }
     if (this.options.sfuFallback?.admission.beginDrain(resource.fence)) {
-      const room = this.rooms.get(resource.fence.roomId);
-      if (room?.codecOperation) {
-        room.codecOperation.drainBeforePreparationKey = managedSfuRoomName(
-          resource.fence,
-        );
-      }
       this.scheduleSfuDrain(resource.fence);
     }
   }
@@ -1744,18 +1309,9 @@ export class HybridMediaRouter {
     return accepted;
   }
 
-  private wakeResourceWaiters(completedDrainKey?: string): void {
-    const roomIds: string[] = [];
-    for (const [roomId, waiter] of this.resourceWaiters) {
-      if (
-        waiter.kind === "drain" &&
-        waiter.drainKey !== completedDrainKey
-      ) {
-        continue;
-      }
-      this.resourceWaiters.delete(roomId);
-      roomIds.push(roomId);
-    }
+  private wakeResourceWaiters(): void {
+    const roomIds = [...this.resourceWaiters];
+    this.resourceWaiters.clear();
     for (const roomId of roomIds) {
       const controller = this.rooms.get(roomId)?.controller;
       if (!controller) continue;
@@ -1936,11 +1492,7 @@ export class HybridMediaRouter {
           throw new Error("LiveKit drain has no matching resource generation");
         }
         this.sfuDrainTasks.delete(key);
-        const room = this.rooms.get(task.fence.roomId);
-        if (room?.codecDrainBarrierKey === key) {
-          room.codecDrainBarrierKey = undefined;
-        }
-        this.wakeResourceWaiters(key);
+        this.wakeResourceWaiters();
       } catch (error) {
         if (this.sfuDrainTasks.get(key) !== task) return;
         if (this.closing) throw error;
@@ -1957,30 +1509,11 @@ export class HybridMediaRouter {
     return tracked;
   }
 
-  private settleCodecPreparation(
-    room: RoomRuntime,
-    snapshot: CodecRouteSnapshot | null,
-  ): void {
-    const resolve = room.codecOperation?.resolvePreparation;
-    if (!resolve) return;
-    room.codecOperation!.resolvePreparation = undefined;
-    resolve(snapshot);
-  }
-
-  private carryCodecDrainBarrier(room: RoomRuntime): void {
-    const key = room.codecOperation?.drainBeforePreparationKey;
-    if (key && this.sfuDrainTasks.has(key)) {
-      room.codecDrainBarrierKey = key;
-    }
-  }
-
   private clearRoom(roomId: string): void {
     const room = this.rooms.get(roomId);
     if (!room) return;
     this.clearDeadline(room);
     this.cancelHostOfflineCheck(roomId);
-    this.settleCodecPreparation(room, null);
-    room.codecOperation = undefined;
     const controller = room.controller;
     room.controller = undefined;
     room.requested = false;
@@ -2012,7 +1545,6 @@ function cursorGuard(
   plan: CandidatePlan,
 ): CandidateCursorGuard {
   return {
-    owner: { ...operation.owner },
     childPeerId: operation.childPeerId,
     childSessionId: operation.childSessionId,
     baseRevision: operation.baseRevision,
@@ -2047,13 +1579,6 @@ function preparedRouteCandidate(
     childPeerId: operation.childPeerId,
     connectionId,
     transport: tuple.kind === "peer" ? tuple.transport : "sfu",
-    codecTransition:
-      operation.owner.kind === "codec"
-        ? {
-            generation: operation.owner.codecGeneration,
-            videoCodec: operation.owner.videoCodec,
-          }
-        : null,
   };
 }
 
diff --git a/src/server/room-route-controller.ts b/src/server/room-route-controller.ts
index 6327c9a..07a7630 100644
--- a/src/server/room-route-controller.ts
+++ b/src/server/room-route-controller.ts
@@ -1,11 +1,9 @@
 import {
   MAX_MEDIA_ROUTE_REVISION,
-  type CodecTransitionGeneration,
   type RouteDemandReason,
   type RouteDiagnosticFinalRoute,
   type RouteDiagnosticRejectionBucket,
   type RouteDiagnosticSnapshot,
-  type VideoCodecPreference,
 } from "../shared/protocol.js";
 import { assertEndpointMediaCopyCapacity } from "../shared/media-copy-accounting.js";
 
@@ -76,7 +74,6 @@ export interface CandidateGuard {
 }
 
 export interface CandidateCursorGuard {
-  owner: OperationOwner;
   childPeerId: string;
   childSessionId: string;
   baseRevision: number;
@@ -115,23 +112,7 @@ interface Attempt<Resource> {
   reservation: CandidateReservation<Resource>;
 }
 
-export type CodecOperationPhase = "preparing" | "prepared" | "proving";
-
-export type OperationOwner =
-  | { kind: "route" }
-  | {
-      kind: "codec";
-      codecGeneration: CodecTransitionGeneration;
-      phase: CodecOperationPhase;
-      videoCodec: VideoCodecPreference;
-      hostSessionId: string;
-      publicationGeneration: string;
-      connectionId: string;
-      publicationConnectionId: string;
-    };
-
 interface ChildOperation<Resource> {
-  owner: OperationOwner;
   childPeerId: string;
   childSessionId: string;
   reason: RouteDemandReason;
@@ -140,12 +121,10 @@ interface ChildOperation<Resource> {
   cursor: number;
   deadlineAtMs: number;
   builtAtFactVersion: number;
-  deferredRetirements: EdgeGuard[];
   current?: Attempt<Resource>;
 }
 
 export interface OperationSnapshot {
-  owner: OperationOwner;
   childPeerId: string;
   childSessionId: string;
   reason: RouteDemandReason;
@@ -188,64 +167,6 @@ export interface BeginResult<Resource> {
   released: readonly Resource[];
 }
 
-export interface RetireTransportsResult<Resource> {
-  accepted: boolean;
-  activeRevision: number;
-  retiredPeerIds: readonly string[];
-  released: readonly Resource[];
-}
-
-export interface CodecOperationGuard {
-  codecGeneration: CodecTransitionGeneration;
-  hostSessionId: string;
-  childPeerId: string;
-  childSessionId: string;
-  publicationGeneration: string;
-  connectionId: string;
-  publicationConnectionId: string;
-}
-
-export interface BeginCodecSfuPublicationInput {
-  routeRevision: number;
-  hostSessionId: string;
-  codecGeneration: CodecTransitionGeneration;
-  videoCodec: VideoCodecPreference;
-  publicationGeneration: string;
-  connectionId: string;
-  publicationConnectionId: string;
-  nowMs: number;
-  deadlineAtMs: number;
-  retainedAnchor?: {
-    childPeerId: string;
-    childSessionId: string;
-  };
-}
-
-export interface BeginCodecSfuPublicationResult<Resource> {
-  accepted: boolean;
-  activeRevision: number;
-  anchorPeerId?: string;
-  guard?: CodecOperationGuard;
-  retiredPeerIds: readonly string[];
-  operation?: OperationSnapshot;
-  released: readonly Resource[];
-}
-
-export interface CodecOperationMutationResult<Resource> {
-  accepted: boolean;
-  activeRevision: number;
-  operation?: OperationSnapshot;
-  released: readonly Resource[];
-}
-
-export interface TransitionCodecOperationInput {
-  guard: CodecOperationGuard;
-  expectedPhase: CodecOperationPhase;
-  phase: CodecOperationPhase;
-  nowMs?: number;
-  deadlineAtMs?: number;
-}
-
 interface HostPublication<Resource> {
   generation: string;
   hostSessionId: string;
@@ -518,242 +439,6 @@ export class RoomRouteController<Resource = unknown> {
     this.assertGraph();
   }
 
-  beginCodecSfuPublication(
-    input: BeginCodecSfuPublicationInput,
-  ): BeginCodecSfuPublicationResult<Resource> {
-    assertCodecOperationInput(input);
-    const rejected = (): BeginCodecSfuPublicationResult<Resource> => ({
-      accepted: false,
-      activeRevision: this.revision,
-      retiredPeerIds: [],
-      released: [],
-    });
-    const host = this.participants.get(this.options.hostPeerId);
-    if (
-      !this.options.sfuEnabled ||
-      !this.paused ||
-      this.operation ||
-      this.revision !== input.routeRevision ||
-      host?.sessionId !== input.hostSessionId ||
-      host.departureConfirmed
-    ) {
-      return rejected();
-    }
-
-    const publication = this.hostPublication;
-    if (
-      publication &&
-      (publication.hostSessionId !== input.hostSessionId ||
-        publication.generation === input.publicationGeneration ||
-        publication.connectionId === input.publicationConnectionId)
-    ) {
-      return rejected();
-    }
-    const publicationViewers = publication
-      ? [...this.upstreamByViewer]
-          .filter(
-            ([, edge]) =>
-              edge.kind === "sfu" &&
-              edge.publicationGeneration === publication.generation,
-          )
-          .map(([peerId]) => this.participants.get(peerId))
-          .filter((participant): participant is Participant =>
-            Boolean(participant?.sessionId && !participant.departureConfirmed),
-          )
-          .sort(compareParticipant)
-      : [];
-    let anchor: Participant | undefined;
-    if (input.retainedAnchor) {
-      const retained = this.participants.get(input.retainedAnchor.childPeerId);
-      const retainedEdge = this.upstreamByViewer.get(
-        input.retainedAnchor.childPeerId,
-      );
-      if (
-        retained?.role !== "viewer" ||
-        retained.sessionId !== input.retainedAnchor.childSessionId ||
-        retained.departureConfirmed ||
-        (publication &&
-          (retainedEdge?.kind !== "sfu" ||
-            retainedEdge.publicationGeneration !== publication.generation ||
-            (publication.physicalActive &&
-              (!retainedEdge.physicalActive || !retainedEdge.usable)))) ||
-        (!publication && retainedEdge)
-      ) {
-        return rejected();
-      }
-      anchor = retained;
-    } else {
-      anchor = publication?.physicalActive
-        ? publicationViewers.find((participant) => {
-            const edge = this.upstreamByViewer.get(participant.peerId);
-            return edge?.physicalActive && edge.usable;
-          })
-        : publicationViewers[0];
-    }
-    if (!anchor?.sessionId) return rejected();
-    const anchorEdge = this.upstreamByViewer.get(anchor.peerId);
-    if (anchorEdge?.connectionId === input.connectionId) return rejected();
-    const copiesAfterRetirement =
-      this.physicalCopies(this.options.hostPeerId) -
-      (publication?.physicalActive ? 1 : 0);
-    if (copiesAfterRetirement + 1 > host.effectiveDownstreamCapacity) {
-      return rejected();
-    }
-
-    const released = new Set<Resource>();
-    const retiredPeerIds: string[] = [];
-    if (publication) {
-      for (const [viewerPeerId, edge] of this.upstreamByViewer) {
-        if (
-          edge.kind !== "sfu" ||
-          edge.publicationGeneration !== publication.generation
-        ) {
-          continue;
-        }
-        if (edge.physicalActive) {
-          released.add(edge.resource);
-          retiredPeerIds.push(viewerPeerId);
-        }
-        edge.physicalActive = false;
-        edge.usable = false;
-        const participant = this.participants.get(viewerPeerId);
-        if (participant) {
-          participant.blockedAtFactVersion = undefined;
-          participant.failedTuple = undefined;
-        }
-        this.recordDemand(viewerPeerId, input.nowMs, "edge-unavailable");
-      }
-      if (publication.physicalActive) released.add(publication.resource);
-      publication.physicalActive = false;
-      publication.usable = false;
-      this.revision = this.allocateRevision();
-      this.touchFacts();
-    }
-
-    const tuple: CandidateTuple = {
-      kind: "sfu",
-      publication: publication ? "replace" : "create",
-    };
-    const plan = this.planCandidate(anchor.peerId, tuple);
-    if (!plan) {
-      throw new Error("Codec SFU publication candidate is not admissible");
-    }
-    this.ensureDemand(anchor.peerId, input.nowMs, "edge-unavailable");
-    this.startOperationTiming(anchor.peerId, input.nowMs);
-    this.operation = {
-      owner: {
-        kind: "codec",
-        codecGeneration: input.codecGeneration,
-        phase: "preparing",
-        videoCodec: input.videoCodec,
-        hostSessionId: input.hostSessionId,
-        publicationGeneration: input.publicationGeneration,
-        connectionId: input.connectionId,
-        publicationConnectionId: input.publicationConnectionId,
-      },
-      childPeerId: anchor.peerId,
-      childSessionId: anchor.sessionId,
-      reason: "edge-unavailable",
-      baseRevision: this.revision,
-      candidates: [plan],
-      cursor: 0,
-      deadlineAtMs: input.deadlineAtMs,
-      builtAtFactVersion: this.factVersion,
-      deferredRetirements: [],
-    };
-    this.assertGraph();
-    const guard = codecOperationGuard(this.operation);
-    return {
-      accepted: true,
-      activeRevision: this.revision,
-      anchorPeerId: anchor.peerId,
-      guard,
-      retiredPeerIds,
-      operation: this.operationSnapshot(),
-      released: [...released],
-    };
-  }
-
-  transitionCodecOperation(
-    input: TransitionCodecOperationInput,
-  ): CodecOperationMutationResult<Resource> {
-    const operation = this.operation;
-    if (
-      !operation ||
-      !codecOperationGuardMatches(input.guard, operation) ||
-      operation.owner.kind !== "codec" ||
-      !operation.current ||
-      operation.owner.phase !== input.expectedPhase ||
-      !codecPhaseTransitionAllowed(input.expectedPhase, input.phase)
-    ) {
-      return {
-        accepted: false,
-        activeRevision: this.revision,
-        operation: this.operationSnapshot(),
-        released: [],
-      };
-    }
-    if (input.phase === "proving") {
-      if (
-        input.nowMs === undefined ||
-        input.deadlineAtMs === undefined ||
-        !Number.isSafeInteger(input.deadlineAtMs) ||
-        input.deadlineAtMs <= input.nowMs
-      ) {
-        throw new Error("Codec proof deadline must be in the future");
-      }
-      operation.deadlineAtMs = input.deadlineAtMs;
-    }
-    operation.owner.phase = input.phase;
-    return {
-      accepted: true,
-      activeRevision: this.revision,
-      operation: this.operationSnapshot(),
-      released: [],
-    };
-  }
-
-  abortCodecOperation(
-    guard: CodecOperationGuard,
-    nowMs?: number,
-  ): CodecOperationMutationResult<Resource> {
-    const operation = this.operation;
-    if (!operation || !codecOperationGuardMatches(guard, operation)) {
-      return {
-        accepted: false,
-        activeRevision: this.revision,
-        operation: this.operationSnapshot(),
-        released: [],
-      };
-    }
-    const released = operation.current
-      ? [...reservationResources(operation.current.reservation)]
-      : [];
-    if (nowMs !== undefined) {
-      this.finishTiming(
-        operation.childPeerId,
-        nowMs,
-        this.currentFinalRoute(operation.childPeerId),
-        "aborted",
-      );
-    }
-    let revisionAdvanced = Boolean(operation.current);
-    if (operation.current) this.advanceActiveRevision(operation);
-    if (this.retireDeferredCodecEdges(operation, released)) {
-      if (!revisionAdvanced) {
-        this.advanceActiveRevision(operation);
-        revisionAdvanced = true;
-      }
-      this.touchFacts();
-    }
-    this.operation = undefined;
-    return {
-      accepted: true,
-      activeRevision: this.revision,
-      released,
-    };
-  }
-
   invalidateEdge(guard: EdgeGuard, nowMs?: number): boolean {
     const child = this.participants.get(guard.childPeerId);
     const edge = this.upstreamByViewer.get(guard.childPeerId);
@@ -849,92 +534,6 @@ export class RoomRouteController<Resource = unknown> {
     return edge.transport === "direct" ? [] : [edge.resource];
   }
 
-  retireCommittedTransportsForRouteWait(
-    guards: readonly EdgeGuard[],
-    nowMs: number,
-  ): RetireTransportsResult<Resource> {
-    const childPeerIds = new Set<string>();
-    const owned: Array<{
-      childPeerId: string;
-      child: Participant;
-      edge: CommittedEdge<Resource>;
-    }> = [];
-    const codecOperation =
-      this.operation?.owner.kind === "codec" ? this.operation : undefined;
-    if (
-      !this.paused ||
-      (this.operation && !codecOperation) ||
-      guards.length === 0
-    ) {
-      return {
-        accepted: false,
-        activeRevision: this.revision,
-        retiredPeerIds: [],
-        released: [],
-      };
-    }
-    for (const guard of guards) {
-      const child = this.participants.get(guard.childPeerId);
-      const edge = this.upstreamByViewer.get(guard.childPeerId);
-      if (
-        childPeerIds.has(guard.childPeerId) ||
-        guard.routeRevision !== this.revision ||
-        !child ||
-        child.sessionId !== guard.childSessionId ||
-        !edge ||
-        !edge.physicalActive ||
-        edge.childSessionId !== guard.childSessionId ||
-        edge.connectionId !== guard.connectionId ||
-        (edge.kind === "peer" &&
-          edge.parentSessionId !== guard.parentSessionId)
-      ) {
-        return {
-          accepted: false,
-          activeRevision: this.revision,
-          retiredPeerIds: [],
-          released: [],
-        };
-      }
-      childPeerIds.add(guard.childPeerId);
-      owned.push({ childPeerId: guard.childPeerId, child, edge });
-    }
-
-    const released: Resource[] = [];
-    let invalidated = false;
-    for (const { childPeerId, child, edge } of owned) {
-      if (edge.usable) {
-        edge.usable = false;
-        this.recordDemand(childPeerId, nowMs, "edge-unavailable");
-        invalidated = true;
-      }
-      child.blockedAtFactVersion = undefined;
-      child.failedTuple = undefined;
-    }
-    if (codecOperation) {
-      const deferred = guards.filter(
-        (guard) =>
-          !codecOperation.deferredRetirements.some((candidate) =>
-            edgeGuardEquals(candidate, guard),
-          ),
-      );
-      codecOperation.deferredRetirements.push(
-        ...deferred.map((guard) => ({ ...guard })),
-      );
-      if (invalidated) this.touchFacts();
-      codecOperation.builtAtFactVersion = this.factVersion;
-    } else if (invalidated) {
-      this.revision = this.allocateRevision();
-      this.touchFacts();
-    }
-    this.assertGraph();
-    return {
-      accepted: true,
-      activeRevision: this.revision,
-      retiredPeerIds: [...childPeerIds],
-      released,
-    };
-  }
-
   retireHostPublication(guard: {
     hostSessionId: string;
     routeRevision: number;
@@ -1009,7 +608,6 @@ export class RoomRouteController<Resource = unknown> {
       }
       this.startOperationTiming(childPeerId, nowMs);
       this.operation = {
-        owner: { kind: "route" },
         childPeerId,
         childSessionId: child.sessionId!,
         reason,
@@ -1018,7 +616,6 @@ export class RoomRouteController<Resource = unknown> {
         cursor: 0,
         deadlineAtMs: nowMs + this.options.operationTimeoutMs,
         builtAtFactVersion: this.factVersion,
-        deferredRetirements: [],
       };
       return {
         operation: this.operationSnapshot(),
@@ -1057,27 +654,6 @@ export class RoomRouteController<Resource = unknown> {
         exhausted: validation.exhausted,
       };
     }
-    if (
-      operation.owner.kind === "codec" &&
-      (operation.owner.phase !== "preparing" ||
-        plan.tuple.kind !== "sfu" ||
-        this.participants.get(this.options.hostPeerId)?.sessionId !==
-          operation.owner.hostSessionId ||
-        input.connectionId !== operation.owner.connectionId ||
-        input.publicationGeneration !==
-          operation.owner.publicationGeneration ||
-        input.publicationConnectionId !==
-          operation.owner.publicationConnectionId)
-    ) {
-      return {
-        accepted: false,
-        operation: this.operationSnapshot(),
-        released: [
-          ...validation.released,
-          ...reservationResources(input.reservation),
-        ],
-      };
-    }
     if (plan.endpointTransition.kind === "bounded-gap") {
       return {
         accepted: false,
@@ -1238,16 +814,6 @@ export class RoomRouteController<Resource = unknown> {
     const validation = this.validateOrAdvance(nowMs);
     const operation = this.operation;
     const attempt = operation?.current;
-    if (
-      operation?.owner.kind === "codec" &&
-      operation.owner.phase !== "proving"
-    ) {
-      return {
-        accepted: false,
-        activeRevision: this.revision,
-        released: validation.released,
-      };
-    }
     if (!operation || !attempt || !this.guardMatches(guard, operation, attempt)) {
       return { accepted: false, exhausted: validation.exhausted, activeRevision: this.revision, released: validation.released };
     }
@@ -1339,13 +905,7 @@ export class RoomRouteController<Resource = unknown> {
     } = { released, expired: false, consumedGuard: false };
     let operation = this.operation;
     if (!operation) return result;
-    if (
-      !(
-        operation.owner.kind === "codec" &&
-        operation.owner.phase === "prepared"
-      ) &&
-      nowMs >= operation.deadlineAtMs
-    ) {
+    if (nowMs >= operation.deadlineAtMs) {
       if (operation.current) released.push(...reservationResources(operation.current.reservation));
       const revisionAdvanced = Boolean(operation.current);
       if (operation.current) this.advanceActiveRevision(operation);
@@ -1376,12 +936,7 @@ export class RoomRouteController<Resource = unknown> {
     }
     if (this.participants.get(operation.childPeerId)?.sessionId !== operation.childSessionId) {
       if (operation.current) released.push(...reservationResources(operation.current.reservation));
-      const revisionAdvanced = Boolean(operation.current);
       if (operation.current) this.advanceActiveRevision(operation);
-      if (this.retireDeferredCodecEdges(operation, released)) {
-        if (!revisionAdvanced) this.advanceActiveRevision(operation);
-        this.touchFacts();
-      }
       this.finishTiming(
         operation.childPeerId,
         nowMs,
@@ -1448,17 +1003,9 @@ export class RoomRouteController<Resource = unknown> {
   private commitAttempt(operation: ChildOperation<Resource>, attempt: Attempt<Resource>): Resource[] {
     const beforeResources = new Set(this.committedResources());
     const old = this.upstreamByViewer.get(operation.childPeerId);
-    const codecReplacementGeneration =
-      operation.owner.kind === "codec" &&
-      attempt.tuple.kind === "sfu" &&
-      attempt.tuple.publication === "replace"
-        ? this.hostPublication?.generation
-        : undefined;
 
     if (attempt.tuple.kind === "sfu" && attempt.tuple.publication === "replace") {
-      if (operation.owner.kind === "route") {
-        this.removePublicationGeneration(this.hostPublication!.generation);
-      }
+      this.removePublicationGeneration(this.hostPublication!.generation);
     }
 
     if (attempt.tuple.kind === "peer") {
@@ -1489,20 +1036,6 @@ export class RoomRouteController<Resource = unknown> {
           resource: reservation.publication,
         };
       }
-      if (codecReplacementGeneration) {
-        for (const [viewerPeerId, existing] of this.upstreamByViewer) {
-          if (
-            viewerPeerId === operation.childPeerId ||
-            existing.kind !== "sfu" ||
-            existing.publicationGeneration !== codecReplacementGeneration
-          ) {
-            continue;
-          }
-          existing.publicationGeneration = generation;
-          existing.usable = false;
-          existing.physicalActive = false;
-        }
-      }
       const edge = (attempt.reservation as Extract<CandidateReservation<Resource>, { kind: "sfu-reuse" | "sfu-create" }>).edge;
       this.upstreamByViewer.set(operation.childPeerId, {
         kind: "sfu", childSessionId: operation.childSessionId,
@@ -1511,7 +1044,6 @@ export class RoomRouteController<Resource = unknown> {
       });
     }
     this.revision = attempt.revision;
-    this.retireDeferredCodecEdges(operation);
     this.operation = undefined;
     this.touchFacts();
     const participant = this.participants.get(operation.childPeerId);
@@ -1767,12 +1299,7 @@ export class RoomRouteController<Resource = unknown> {
     const released = operation.current
       ? [...reservationResources(operation.current.reservation)]
       : [];
-    const revisionAdvanced = Boolean(operation.current);
     if (operation.current) this.advanceActiveRevision(operation);
-    if (this.retireDeferredCodecEdges(operation, released)) {
-      if (!revisionAdvanced) this.advanceActiveRevision(operation);
-      this.touchFacts();
-    }
     this.operation = undefined;
     return released;
   }
@@ -1789,53 +1316,20 @@ export class RoomRouteController<Resource = unknown> {
     revisionAdvanced = false,
   ): void {
     const child = this.participants.get(operation.childPeerId);
-    const retiredDeferred = this.retireDeferredCodecEdges(operation, released);
     this.operation = undefined;
     const retiredInvalid = block && child
       ? this.retireInvalidOperationEdge(operation.childPeerId, released)
       : false;
-    if ((retiredDeferred || retiredInvalid) && !revisionAdvanced) {
+    if (retiredInvalid && !revisionAdvanced) {
       this.revision = this.allocateRevision();
     }
-    if (retiredDeferred || retiredInvalid) {
+    if (retiredInvalid) {
       this.touchFacts();
     }
     if (!block || !child) return;
     child.blockedAtFactVersion = this.factVersion;
   }
 
-  private retireDeferredCodecEdges(
-    operation: ChildOperation<Resource>,
-    released: Resource[] = [],
-  ): boolean {
-    if (
-      operation.owner.kind !== "codec" ||
-      operation.deferredRetirements.length === 0
-    ) {
-      return false;
-    }
-    let retired = false;
-    for (const guard of operation.deferredRetirements) {
-      const edge = this.upstreamByViewer.get(guard.childPeerId);
-      if (
-        !edge ||
-        !edge.physicalActive ||
-        edge.childSessionId !== guard.childSessionId ||
-        edge.connectionId !== guard.connectionId ||
-        (edge.kind === "peer" &&
-          edge.parentSessionId !== guard.parentSessionId)
-      ) {
-        continue;
-      }
-      edge.physicalActive = false;
-      edge.usable = false;
-      if (edge.kind === "sfu") released.push(edge.resource);
-      retired = true;
-    }
-    operation.deferredRetirements = [];
-    return retired;
-  }
-
   private retireInvalidOperationEdge(childPeerId: string, released: Resource[]): boolean {
     const edge = this.upstreamByViewer.get(childPeerId);
     if (!edge || !this.edgeRequiresMove(childPeerId, edge)) return false;
@@ -1887,8 +1381,7 @@ export class RoomRouteController<Resource = unknown> {
   private operationSnapshot(): OperationSnapshot | undefined {
     const operation = this.operation;
     if (!operation) return undefined;
-    return { owner: { ...operation.owner },
-      childPeerId: operation.childPeerId, childSessionId: operation.childSessionId,
+    return { childPeerId: operation.childPeerId, childSessionId: operation.childSessionId,
       reason: operation.reason,
       baseRevision: operation.baseRevision, factVersion: operation.builtAtFactVersion,
       candidates: operation.candidates.map(cloneCandidatePlan),
@@ -1903,12 +1396,6 @@ export class RoomRouteController<Resource = unknown> {
     nowMs: number,
     released: Resource[],
   ): boolean {
-    if (
-      operation.owner.kind === "codec" &&
-      operation.owner.phase === "prepared"
-    ) {
-      return false;
-    }
     const plan = operation.current
       ? { tuple: operation.current.tuple }
       : operation.candidates[operation.cursor];
@@ -2008,7 +1495,7 @@ export class RoomRouteController<Resource = unknown> {
 
   private cursorGuardMatches(guard: CandidateCursorGuard, operation: ChildOperation<Resource>): boolean {
     const plan = operation.candidates[operation.cursor];
-    return Boolean(plan && operationOwnerEquals(guard.owner, operation.owner) &&
+    return Boolean(plan &&
       guard.childPeerId === operation.childPeerId &&
       guard.childSessionId === operation.childSessionId && guard.baseRevision === operation.baseRevision &&
       guard.factVersion === operation.builtAtFactVersion && guard.cursor === operation.cursor &&
@@ -2326,102 +1813,6 @@ export class RoomRouteController<Resource = unknown> {
   }
 }
 
-function codecOperationGuard<Resource>(
-  operation: ChildOperation<Resource>,
-): CodecOperationGuard {
-  if (operation.owner.kind !== "codec") {
-    throw new Error("Route operation is not codec-owned");
-  }
-  return {
-    codecGeneration: operation.owner.codecGeneration,
-    hostSessionId: operation.owner.hostSessionId,
-    childPeerId: operation.childPeerId,
-    childSessionId: operation.childSessionId,
-    publicationGeneration: operation.owner.publicationGeneration,
-    connectionId: operation.owner.connectionId,
-    publicationConnectionId: operation.owner.publicationConnectionId,
-  };
-}
-
-function codecOperationGuardMatches<Resource>(
-  guard: CodecOperationGuard,
-  operation: ChildOperation<Resource>,
-): boolean {
-  return (
-    operation.owner.kind === "codec" &&
-    operation.owner.codecGeneration === guard.codecGeneration &&
-    operation.owner.hostSessionId === guard.hostSessionId &&
-    operation.childPeerId === guard.childPeerId &&
-    operation.childSessionId === guard.childSessionId &&
-    operation.owner.publicationGeneration ===
-      guard.publicationGeneration &&
-    operation.owner.connectionId === guard.connectionId &&
-    operation.owner.publicationConnectionId ===
-      guard.publicationConnectionId
-  );
-}
-
-function operationOwnerEquals(left: OperationOwner, right: OperationOwner): boolean {
-  if (left.kind !== right.kind) return false;
-  if (left.kind === "route" || right.kind === "route") return true;
-  return (
-    left.codecGeneration === right.codecGeneration &&
-    left.phase === right.phase &&
-    left.videoCodec === right.videoCodec &&
-    left.hostSessionId === right.hostSessionId &&
-    left.publicationGeneration === right.publicationGeneration &&
-    left.connectionId === right.connectionId &&
-    left.publicationConnectionId === right.publicationConnectionId
-  );
-}
-
-function edgeGuardEquals(left: EdgeGuard, right: EdgeGuard): boolean {
-  return (
-    left.childPeerId === right.childPeerId &&
-    left.childSessionId === right.childSessionId &&
-    left.parentSessionId === right.parentSessionId &&
-    left.routeRevision === right.routeRevision &&
-    left.connectionId === right.connectionId
-  );
-}
-
-function codecPhaseTransitionAllowed(
-  from: CodecOperationPhase,
-  to: CodecOperationPhase,
-): boolean {
-  return (
-    (from === "preparing" && to === "prepared") ||
-    (from === "prepared" && to === "proving") ||
-    (from === "proving" && to === "prepared")
-  );
-}
-
-function assertCodecOperationInput(input: BeginCodecSfuPublicationInput): void {
-  if (!Number.isSafeInteger(input.codecGeneration) || input.codecGeneration <= 0) {
-    throw new Error("Codec generation must be a positive safe integer");
-  }
-  if (
-    !Number.isFinite(input.nowMs) ||
-    !Number.isSafeInteger(input.deadlineAtMs) ||
-    input.deadlineAtMs <= input.nowMs
-  ) {
-    throw new Error("Codec preparation deadline must be in the future");
-  }
-  if (
-    ![input.publicationGeneration, input.connectionId, input.publicationConnectionId]
-      .every((value) => value.length > 0)
-  ) {
-    throw new Error("Codec SFU identity is invalid");
-  }
-  if (
-    input.retainedAnchor &&
-    (!input.retainedAnchor.childPeerId ||
-      !input.retainedAnchor.childSessionId)
-  ) {
-    throw new Error("Codec SFU retained anchor is invalid");
-  }
-}
-
 function compareParticipant(left: Participant, right: Participant): number {
   return left.joinOrder - right.joinOrder || left.peerId.localeCompare(right.peerId);
 }
diff --git a/src/server/signaling.ts b/src/server/signaling.ts
index 674810b..3c60b57 100644
--- a/src/server/signaling.ts
+++ b/src/server/signaling.ts
@@ -15,10 +15,8 @@ import {
   VIEWER_QUALITY_EVIDENCE_INTERVAL_MS,
   decodeClientMessage,
   type ClientMessage,
-  type CodecTransitionGeneration,
   type CodeEntryPolicy,
   type QualitySettings,
-  type ResumeAttempt,
   type Role,
   type ServerMessage,
   type ParticipantPresenceEntry,
@@ -34,7 +32,6 @@ import {
   HybridMediaRouter,
   type SfuFallbackOptions,
 } from "./hybrid-media-router.js";
-import { CodecTransitionCoordinator } from "./codec-transition.js";
 import { createIceConfig, type IceConfigOptions } from "./ice.js";
 
 type ErrorCode = Extract<ServerMessage, { type: "error" }>["code"];
@@ -130,7 +127,6 @@ export class SignalingServer {
     Set<string>
   >();
   private readonly hybridMediaRouter?: HybridMediaRouter;
-  private readonly codecTransitions?: CodecTransitionCoordinator;
   private readonly now: () => number;
   private readonly authenticationTimeoutMs: number;
   private readonly viewerDisconnectGraceMs: number;
@@ -181,7 +177,6 @@ export class SignalingServer {
         getShareGeneration: (roomId) => this.shareGenerationsByRoom.get(roomId),
         onActiveRouteChanged: (roomId) => {
           this.viewerMediaReadyByRoom.delete(roomId);
-          this.codecTransitions?.participantChanged(roomId);
           this.sendViewerPresence(roomId);
         },
         onViewerMediaState: (
@@ -203,81 +198,6 @@ export class SignalingServer {
         now: this.now,
       });
     }
-    this.codecTransitions = new CodecTransitionCoordinator({
-      snapshot: (roomId) =>
-        this.hybridMediaRouter?.codecRouteSnapshot(roomId) ?? {
-          revision: 0,
-          targets: [],
-        },
-      sendToSession: (sessionId, message) =>
-        this.sendToSession(sessionId, message),
-      commitCodec: (roomId, videoCodec) =>
-        this.commitRoomVideoCodec(roomId, videoCodec),
-      authorizeResume: (
-        roomId,
-        hostSessionId,
-        shareGeneration,
-        codecGeneration,
-        resumeAttempt,
-      ) =>
-        this.authorizeSharingResume(
-          roomId,
-          hostSessionId,
-          shareGeneration,
-          codecGeneration,
-          resumeAttempt,
-        ),
-      confirmSourceEnabled: (
-        roomId,
-        hostSessionId,
-        shareGeneration,
-        codecGeneration,
-        resumeAttempt,
-      ) =>
-        this.confirmSharingSourceEnabled(
-          roomId,
-          hostSessionId,
-          shareGeneration,
-          codecGeneration,
-          resumeAttempt,
-        ),
-      restoreAuthoritativePause: (
-        roomId,
-        hostSessionId,
-        shareGeneration,
-        codecGeneration,
-        resumeAttempt,
-      ) =>
-        this.restoreAuthoritativePause(
-          roomId,
-          hostSessionId,
-          shareGeneration,
-          codecGeneration,
-          resumeAttempt,
-        ),
-      returnTargetsToRouteWait: (roomId, viewerPeerIds) =>
-        this.hybridMediaRouter?.routeWaitInvalidCodecTargets(
-          roomId,
-          viewerPeerIds,
-        ),
-      beginSfuReplacement: (input) =>
-        this.hybridMediaRouter?.beginCodecSfuReplacement(input) ??
-        Promise.resolve(null),
-      parkSfuReplacement: (roomId, generation) =>
-        this.hybridMediaRouter?.parkCodecSfuReplacement(roomId, generation) ??
-        false,
-      beginSfuProof: (roomId, generation, timeoutMs) =>
-        this.hybridMediaRouter?.beginCodecSfuProof(
-          roomId,
-          generation,
-          timeoutMs,
-        ) ?? false,
-      abortSfuReplacement: (roomId, generation) =>
-        this.hybridMediaRouter?.abortCodecSfuReplacement(roomId, generation),
-      releaseRoutePause: (roomId) =>
-        this.hybridMediaRouter?.setPaused(roomId, false),
-      now: this.now,
-    });
 
     this.upgradeHandler = (request, socket, head) => {
       let requestUrl: URL;
@@ -338,7 +258,6 @@ export class SignalingServer {
       clearTimeout(timer);
     }
     this.viewerGraceTimers.clear();
-    this.codecTransitions?.close();
     let routeCloseError: unknown;
     try {
       await this.hybridMediaRouter?.close();
@@ -579,10 +498,28 @@ export class SignalingServer {
       ) {
         this.stopSharing(participant.roomId);
       }
+      if (
+        message.shareGeneration !== undefined &&
+        (currentGeneration !== shareGeneration ||
+          !this.qualitySettingsByRoom.has(participant.roomId))
+      ) {
+        const initialQualitySettings =
+          message.qualitySettings ?? DEFAULT_QUALITY_SETTINGS;
+        this.qualitySettingsByRoom.set(participant.roomId, {
+          ...initialQualitySettings,
+        });
+        for (const viewer of this.options.roomStore.getConnectedViewers(
+          participant.roomId,
+        )) {
+          this.sendToSession(viewer.sessionId, {
+            type: "quality-settings",
+            qualitySettings: initialQualitySettings,
+          });
+        }
+      }
       this.shareGenerationsByRoom.set(participant.roomId, shareGeneration);
       if (
         message.sharingPaused === true ||
-        this.codecTransitions?.blocksResume(participant.roomId) ||
         sameShareWasAuthoritativelyPaused
       ) {
         this.pausedShareGenerationsByRoom.set(
@@ -723,12 +660,7 @@ export class SignalingServer {
     }
 
     if (participant.role === "host") {
-      if (this.codecTransitions?.blocksResume(participant.roomId)) {
-        this.codecTransitions.invalidateHostSession(
-          participant.roomId,
-          state.sessionId,
-        );
-      } else if (
+      if (
         shareGeneration !== null &&
         this.pausedShareGenerationsByRoom.get(participant.roomId) ===
           shareGeneration
@@ -736,8 +668,6 @@ export class SignalingServer {
         this.sendToSession(state.sessionId, {
           type: "pause-sharing-source",
           shareGeneration,
-          codecGeneration: null,
-          resumeAttempt: null,
         });
       }
     }
@@ -869,7 +799,7 @@ export class SignalingServer {
           this.sendError(
             socket,
             "FORBIDDEN",
-            "视频编码只能在分享暂停后切换",
+            "视频编码只能在开始分享前选择；请停止分享后重新开始",
           );
           return;
         }
@@ -1072,175 +1002,26 @@ export class SignalingServer {
           socket.close(SIGNAL_CLOSE_CODES.sessionReplaced, "Sharing generation replaced");
           return;
         }
-        this.pausedShareGenerationsByRoom.set(
-          authenticated.roomId,
-          authenticated.shareGeneration,
-        );
-        this.codecTransitions?.pause({
-          roomId: authenticated.roomId,
-          hostSessionId: pauseSocketState.sessionId,
-          shareGeneration: authenticated.shareGeneration,
-        });
-        if (this.isHybridMediaEnabled()) {
-          this.hybridMediaRouter!.setPaused(authenticated.roomId, true);
-        }
-        this.broadcastHostStatus(authenticated.roomId, true, true);
-        return;
-      case "request-sharing-resume": {
-        if (authenticated.role !== "host") {
-          this.sendError(socket, "FORBIDDEN", "只有当前分享者可以恢复分享");
-          return;
-        }
-        const resumeState = this.socketStates.get(socket);
-        const currentHost = this.options.roomStore.getConnectedHost(
-          authenticated.roomId,
-        );
-        if (
-          !resumeState ||
-          currentHost?.sessionId !== resumeState.sessionId ||
-          authenticated.shareGeneration === null ||
-          this.shareGenerationsByRoom.get(authenticated.roomId) !==
-            authenticated.shareGeneration ||
-          this.pausedShareGenerationsByRoom.get(authenticated.roomId) !==
-            authenticated.shareGeneration ||
-          message.shareGeneration !== authenticated.shareGeneration
-        ) {
-          socket.close(SIGNAL_CLOSE_CODES.sessionReplaced, "Sharing generation replaced");
-          return;
-        }
-        const result = this.codecTransitions!.requestResume({
-          roomId: authenticated.roomId,
-          hostSessionId: resumeState.sessionId,
-          shareGeneration: authenticated.shareGeneration,
-        });
-        if (result === "busy") {
-          this.sendError(
-            socket,
-            "FORBIDDEN",
-            "视频编码尚未准备完成",
-          );
-        }
-        return;
-      }
-      case "sharing-source-enabled": {
-        if (authenticated.role !== "host") {
-          this.sendError(socket, "FORBIDDEN", "只有当前分享者可以确认恢复分享");
-          return;
-        }
-        const sourceState = this.socketStates.get(socket);
-        const currentHost = this.options.roomStore.getConnectedHost(
-          authenticated.roomId,
-        );
-        if (
-          !sourceState ||
-          currentHost?.sessionId !== sourceState.sessionId ||
-          authenticated.shareGeneration === null ||
-          this.shareGenerationsByRoom.get(authenticated.roomId) !==
-            authenticated.shareGeneration ||
-          message.shareGeneration !== authenticated.shareGeneration
-        ) {
-          socket.close(SIGNAL_CLOSE_CODES.sessionReplaced, "Sharing generation replaced");
-          return;
-        }
-        if (
-          !this.codecTransitions!.sourceEnabled({
-            roomId: authenticated.roomId,
-            hostSessionId: sourceState.sessionId,
-            shareGeneration: authenticated.shareGeneration,
-            codecGeneration: message.codecGeneration,
-            resumeAttempt: message.resumeAttempt,
-          })
-        ) {
-          this.rejectSharingSourceAcknowledgement(
+        if (message.paused) {
+          this.pausedShareGenerationsByRoom.set(
             authenticated.roomId,
-            sourceState.sessionId,
             authenticated.shareGeneration,
-            message.codecGeneration,
-            message.resumeAttempt,
+          );
+        } else {
+          this.pausedShareGenerationsByRoom.delete(authenticated.roomId);
+        }
+        if (this.isHybridMediaEnabled()) {
+          this.hybridMediaRouter!.setPaused(
+            authenticated.roomId,
+            message.paused,
           );
         }
-        return;
-      }
-      case "request-video-codec-transition": {
-        if (
-          authenticated.role !== "host" ||
-          !this.isHybridMediaEnabled()
-        ) {
-          this.sendError(socket, "FORBIDDEN", "只有当前分享者可以切换视频编码");
-          return;
-        }
-        const transitionState = this.socketStates.get(socket);
-        const currentHost = this.options.roomStore.getConnectedHost(
+        this.broadcastHostStatus(
           authenticated.roomId,
+          true,
+          message.paused,
         );
-        if (
-          !transitionState ||
-          currentHost?.sessionId !== transitionState.sessionId ||
-          authenticated.shareGeneration === null ||
-          this.shareGenerationsByRoom.get(authenticated.roomId) !==
-            authenticated.shareGeneration ||
-          this.pausedShareGenerationsByRoom.get(authenticated.roomId) !==
-            authenticated.shareGeneration ||
-          message.shareGeneration !== authenticated.shareGeneration
-        ) {
-          socket.close(SIGNAL_CLOSE_CODES.sessionReplaced, "Sharing generation replaced");
-          return;
-        }
-        const previous = videoCodec(
-          this.qualitySettingsByRoom.get(authenticated.roomId) ??
-            DEFAULT_QUALITY_SETTINGS,
-        );
-        if (previous === message.videoCodec) {
-          return;
-        }
-        const result = this.codecTransitions!.start({
-          roomId: authenticated.roomId,
-          hostSessionId: transitionState.sessionId,
-          shareGeneration: authenticated.shareGeneration,
-          requested: message.videoCodec,
-          previous,
-        });
-        if (result === "busy" || result === "unavailable") {
-          this.sendError(
-            socket,
-            result === "busy" ? "FORBIDDEN" : "SERVER_ERROR",
-            result === "busy"
-              ? "已有视频编码切换正在进行"
-              : "当前媒体线路不可用",
-          );
-        }
         return;
-      }
-      case "video-codec-prepared": {
-        if (!this.isHybridMediaEnabled()) {
-          this.sendError(socket, "FORBIDDEN", "当前未启用媒体线路");
-          return;
-        }
-        const state = this.socketStates.get(socket);
-        if (state?.authenticated === authenticated) {
-          this.codecTransitions!.prepared(
-            authenticated.roomId,
-            state.sessionId,
-            message,
-          );
-        }
-        return;
-      }
-      case "video-codec-proof": {
-        if (!this.isHybridMediaEnabled() || authenticated.role !== "viewer") {
-          this.sendError(socket, "FORBIDDEN", "只有当前观看者可以确认已解码画面");
-          return;
-        }
-        const state = this.socketStates.get(socket);
-        if (state?.authenticated === authenticated) {
-          this.codecTransitions!.proof(
-            authenticated.roomId,
-            state.sessionId,
-            message,
-          );
-        }
-        return;
-      }
       case "stop-sharing":
         if (authenticated.role !== "host") {
           this.sendError(socket, "FORBIDDEN", "只有当前分享者可以停止分享");
@@ -1764,14 +1545,11 @@ export class SignalingServer {
       );
     }
     if (disconnected.role === "host") {
-      this.codecTransitions?.invalidateHostSession(disconnected.roomId);
       this.broadcastHostStatus(disconnected.roomId, false, false);
       this.sendViewerPresence(disconnected.roomId);
       return;
     }
 
-    this.codecTransitions?.participantChanged(disconnected.roomId);
-
     this.sendViewerPresence(disconnected.roomId);
 
     const key = viewerGraceKey(disconnected.roomId, disconnected.peerId);
@@ -1821,7 +1599,7 @@ export class SignalingServer {
   }
 
   private stopSharing(roomId: string): void {
-    this.codecTransitions?.clearRoom(roomId);
+    this.qualitySettingsByRoom.delete(roomId);
     this.pausedShareGenerationsByRoom.delete(roomId);
     this.clearRoomConnectionIds(roomId);
     if (this.isHybridMediaEnabled()) {
@@ -1845,7 +1623,6 @@ export class SignalingServer {
     this.clearRoomGraceTimers(roomId);
     this.clearRoomConnectionIds(roomId);
     this.ordinaryActiveHostChildrenByRoom.delete(roomId);
-    this.codecTransitions?.clearRoom(roomId);
     if (this.isHybridMediaEnabled()) {
       this.hybridMediaRouter!.deleteRoom(roomId);
     }
@@ -1867,7 +1644,6 @@ export class SignalingServer {
       this.clearRoomGraceTimers(expired.roomId);
       this.clearRoomConnectionIds(expired.roomId);
       this.ordinaryActiveHostChildrenByRoom.delete(expired.roomId);
-      this.codecTransitions?.clearRoom(expired.roomId);
       if (this.isHybridMediaEnabled()) {
         this.hybridMediaRouter!.deleteRoom(expired.roomId);
       }
@@ -2164,118 +1940,6 @@ export class SignalingServer {
     }
   }
 
-  private commitRoomVideoCodec(
-    roomId: string,
-    nextVideoCodec: VideoCodecPreference,
-  ): void {
-    const qualitySettings = {
-      ...(this.qualitySettingsByRoom.get(roomId) ?? DEFAULT_QUALITY_SETTINGS),
-      videoCodec: nextVideoCodec,
-    };
-    this.qualitySettingsByRoom.set(roomId, qualitySettings);
-    for (const viewer of this.options.roomStore.getConnectedViewers(roomId)) {
-      this.sendToSession(viewer.sessionId, {
-        type: "quality-settings",
-        qualitySettings,
-      });
-    }
-  }
-
-  private authorizeSharingResume(
-    roomId: string,
-    hostSessionId: string,
-    shareGeneration: string,
-    codecGeneration: CodecTransitionGeneration | null,
-    resumeAttempt: ResumeAttempt,
-  ): void {
-    const host = this.options.roomStore.getConnectedHost(roomId);
-    if (
-      host?.sessionId !== hostSessionId ||
-      this.shareGenerationsByRoom.get(roomId) !== shareGeneration ||
-      this.pausedShareGenerationsByRoom.get(roomId) !== shareGeneration
-    ) {
-      return;
-    }
-    this.sendToSession(hostSessionId, {
-      type: "sharing-resume-authorized",
-      shareGeneration,
-      codecGeneration,
-      resumeAttempt,
-    });
-  }
-
-  private confirmSharingSourceEnabled(
-    roomId: string,
-    hostSessionId: string,
-    shareGeneration: string,
-    _codecGeneration: CodecTransitionGeneration | null,
-    _resumeAttempt: ResumeAttempt,
-  ): boolean {
-    const host = this.options.roomStore.getConnectedHost(roomId);
-    if (
-      host?.sessionId !== hostSessionId ||
-      this.shareGenerationsByRoom.get(roomId) !== shareGeneration ||
-      this.pausedShareGenerationsByRoom.get(roomId) !== shareGeneration
-    ) {
-      return false;
-    }
-    this.pausedShareGenerationsByRoom.delete(roomId);
-    this.sendToSession(hostSessionId, {
-      type: "host-status",
-      online: true,
-      paused: false,
-    });
-    this.broadcastHostStatus(roomId, true, false);
-    return true;
-  }
-
-  private restoreAuthoritativePause(
-    roomId: string,
-    hostSessionId: string,
-    shareGeneration: string,
-    codecGeneration: CodecTransitionGeneration | null,
-    resumeAttempt: ResumeAttempt | null,
-  ): void {
-    if (this.shareGenerationsByRoom.get(roomId) !== shareGeneration) {
-      return;
-    }
-    this.pausedShareGenerationsByRoom.set(roomId, shareGeneration);
-    this.hybridMediaRouter?.setPaused(roomId, true);
-    const host = this.options.roomStore.getConnectedHost(roomId);
-    if (host?.sessionId === hostSessionId) {
-      this.sendToSession(hostSessionId, {
-        type: "pause-sharing-source",
-        shareGeneration,
-        codecGeneration,
-        resumeAttempt,
-      });
-      this.broadcastHostStatus(roomId, true, true);
-    }
-  }
-
-  private rejectSharingSourceAcknowledgement(
-    roomId: string,
-    hostSessionId: string,
-    shareGeneration: string,
-    codecGeneration: CodecTransitionGeneration | null,
-    resumeAttempt: ResumeAttempt,
-  ): void {
-    if (
-      this.shareGenerationsByRoom.get(roomId) !== shareGeneration ||
-      this.pausedShareGenerationsByRoom.get(roomId) !== shareGeneration ||
-      this.options.roomStore.getConnectedHost(roomId)?.sessionId !==
-        hostSessionId
-    ) {
-      return;
-    }
-    this.sendToSession(hostSessionId, {
-      type: "pause-sharing-source",
-      shareGeneration,
-      codecGeneration,
-      resumeAttempt,
-    });
-  }
-
   private broadcastHostStatus(
     roomId: string,
     online: boolean,
@@ -2423,7 +2087,7 @@ function viewerConnectionKey(roomId: string, peerId: string): string {
 }
 
 function videoCodec(settings: QualitySettings): VideoCodecPreference {
-  return settings.videoCodec ?? "automatic";
+  return settings.videoCodec ?? DEFAULT_QUALITY_SETTINGS.videoCodec;
 }
 
 function authenticationErrorMessage(code: ErrorCode): string {
diff --git a/src/shared/protocol.ts b/src/shared/protocol.ts
index 3dc6e90..0dac309 100644
--- a/src/shared/protocol.ts
+++ b/src/shared/protocol.ts
@@ -6,7 +6,7 @@ import { isCanonicalVideoCodecEvidence } from "./video-codec-evidence.js";
 export const MAX_VIEWERS_PER_ROOM_LIMIT = 20;
 export const MAX_PARTICIPANTS_PER_ROOM_LIMIT = MAX_VIEWERS_PER_ROOM_LIMIT + 1;
 export const MAX_SIGNAL_BYTES = 64 * 1024;
-export const SIGNALING_PROTOCOL = "screener-v9";
+export const SIGNALING_PROTOCOL = "screener-v10";
 export const SIGNAL_CLOSE_CODES = {
   sessionReplaced: 4001,
   clientReconnect: 4002,
@@ -188,85 +188,6 @@ export type VideoCodecPreference = z.infer<
   typeof videoCodecPreferenceSchema
 >;
 
-export const codecTransitionGenerationSchema = z
-  .number()
-  .int()
-  .min(1)
-  .max(Number.MAX_SAFE_INTEGER);
-export type CodecTransitionGeneration = z.infer<
-  typeof codecTransitionGenerationSchema
->;
-export const resumeAttemptSchema = z
-  .number()
-  .int()
-  .min(1)
-  .max(Number.MAX_SAFE_INTEGER);
-export type ResumeAttempt = z.infer<typeof resumeAttemptSchema>;
-export const codecPreparationBindingSchema = z.discriminatedUnion("kind", [
-  z
-    .object({
-      kind: z.literal("peer"),
-      childPeerId: opaqueIdSchema,
-      connectionId: opaqueIdSchema,
-    })
-    .strict(),
-  z
-    .object({
-      kind: z.literal("sfu"),
-      publicationGeneration: opaqueIdSchema,
-    })
-    .strict(),
-]);
-export type CodecPreparationBinding = z.infer<
-  typeof codecPreparationBindingSchema
->;
-
-export const codecProofBindingSchema = z.discriminatedUnion("kind", [
-  z
-    .object({
-      kind: z.literal("peer"),
-      connectionId: opaqueIdSchema,
-    })
-    .strict(),
-  z
-    .object({
-      kind: z.literal("sfu"),
-      connectionId: opaqueIdSchema,
-      publicationGeneration: opaqueIdSchema,
-    })
-    .strict(),
-]);
-export type CodecProofBinding = z.infer<typeof codecProofBindingSchema>;
-
-const codecProofTimestampSchema = z
-  .number()
-  .finite()
-  .min(0)
-  .max(Number.MAX_SAFE_INTEGER);
-const codecProofIdentityStringSchema = z.string().min(1).max(512);
-export const codecProofEvidenceSchema = z
-  .object({
-    baselineSampleTimestampMs: codecProofTimestampSchema,
-    sampleTimestampMs: codecProofTimestampSchema,
-    rtpStatsId: codecProofIdentityStringSchema,
-    rtpSsrc: z.number().int().min(0).max(0xffff_ffff).nullable(),
-    rtpMid: codecProofIdentityStringSchema.nullable(),
-    rtpRid: codecProofIdentityStringSchema.nullable(),
-    trackIdentifier: codecProofIdentityStringSchema.nullable(),
-    framesDecodedDelta: z.number().int().min(1).max(10_000),
-    actualCodec: z.enum(["h264", "vp8", "other"]),
-  })
-  .strict()
-  .refine(
-    (evidence) =>
-      evidence.sampleTimestampMs > evidence.baselineSampleTimestampMs,
-    {
-      message: "Codec proof sample must follow its decoded-frame baseline",
-      path: ["sampleTimestampMs"],
-    },
-  );
-export type CodecProofEvidence = z.infer<typeof codecProofEvidenceSchema>;
-
 export const screenAudioQualitySchema = z.enum([
   "saver",
   "music",
@@ -290,7 +211,7 @@ export const DEFAULT_QUALITY_SETTINGS = {
   maxFramerate: 30,
   maxBitrate: 5_000_000,
   degradationPreference: "balanced",
-  videoCodec: "automatic",
+  videoCodec: "vp8",
   screenAudioQuality: "music",
 } as const satisfies QualitySettings;
 
@@ -379,7 +300,6 @@ export const signalPayloadSchema = z.discriminatedUnion("kind", [
     .object({
       kind: z.literal("description"),
       connectionId: opaqueIdSchema,
-      negotiationGeneration: codecTransitionGenerationSchema.nullable(),
       description: sessionDescriptionSchema,
     })
     .strict(),
@@ -398,13 +318,6 @@ export const preparedRouteCandidateSchema = z
     childPeerId: opaqueIdSchema,
     connectionId: opaqueIdSchema,
     transport: z.enum(["direct", "sfu"]),
-    codecTransition: z
-      .object({
-        generation: codecTransitionGenerationSchema,
-        videoCodec: videoCodecPreferenceSchema,
-      })
-      .strict()
-      .nullable(),
   })
   .strict();
 export type PreparedRouteCandidate = z.infer<
@@ -699,6 +612,7 @@ const authenticateMessageSchema = z.discriminatedUnion("role", [
       clientId: opaqueIdSchema,
       shareGeneration: opaqueIdSchema.optional(),
       sharingPaused: z.boolean().optional(),
+      qualitySettings: qualitySettingsSchema.optional(),
       viewerPresence: z.literal(true).optional(),
       viewerPasswordSettings: z.literal(true).optional(),
       displayName: displayNameSchema.optional(),
@@ -821,48 +735,7 @@ export const clientMessageSchema = z.union([
     .object({
       type: z.literal("set-sharing-paused"),
       shareGeneration: opaqueIdSchema,
-      paused: z.literal(true),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("request-sharing-resume"),
-      shareGeneration: opaqueIdSchema,
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("sharing-source-enabled"),
-      shareGeneration: opaqueIdSchema,
-      codecGeneration: codecTransitionGenerationSchema.nullable(),
-      resumeAttempt: resumeAttemptSchema,
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("request-video-codec-transition"),
-      shareGeneration: opaqueIdSchema,
-      videoCodec: videoCodecPreferenceSchema,
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("video-codec-prepared"),
-      shareGeneration: opaqueIdSchema,
-      generation: codecTransitionGenerationSchema,
-      binding: codecPreparationBindingSchema,
-      accepted: z.boolean(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("video-codec-proof"),
-      shareGeneration: opaqueIdSchema,
-      generation: codecTransitionGenerationSchema,
-      resumeAttempt: resumeAttemptSchema,
-      routeRevision: mediaRouteRevisionSchema,
-      binding: codecProofBindingSchema,
-      evidence: codecProofEvidenceSchema,
+      paused: z.boolean(),
     })
     .strict(),
   z
@@ -1028,61 +901,10 @@ export const serverMessageSchema = z.union([
       qualitySettings: qualitySettingsSchema,
     })
     .strict(),
-  z
-    .object({
-      type: z.literal("video-codec-prepare"),
-      shareGeneration: opaqueIdSchema,
-      generation: codecTransitionGenerationSchema,
-      videoCodec: videoCodecPreferenceSchema,
-      binding: codecPreparationBindingSchema,
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("video-codec-proof-request"),
-      shareGeneration: opaqueIdSchema,
-      generation: codecTransitionGenerationSchema,
-      resumeAttempt: resumeAttemptSchema,
-      routeRevision: mediaRouteRevisionSchema,
-      expectedCodec: z.enum(["h264", "vp8"]).nullable(),
-      binding: codecProofBindingSchema,
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("video-codec-result"),
-      generation: codecTransitionGenerationSchema,
-      videoCodec: videoCodecPreferenceSchema,
-      status: z.enum([
-        "prepared",
-        "committed",
-        "rollback-prepared",
-        "failed",
-      ]),
-      failure: z
-        .enum([
-          "preparation-failed",
-          "proof-failed",
-          "rollback-failed",
-          "stale-binding",
-        ])
-        .nullable(),
-    })
-    .strict(),
-  z
-    .object({
-      type: z.literal("sharing-resume-authorized"),
-      shareGeneration: opaqueIdSchema,
-      codecGeneration: codecTransitionGenerationSchema.nullable(),
-      resumeAttempt: resumeAttemptSchema,
-    })
-    .strict(),
   z
     .object({
       type: z.literal("pause-sharing-source"),
       shareGeneration: opaqueIdSchema,
-      codecGeneration: codecTransitionGenerationSchema.nullable(),
-      resumeAttempt: resumeAttemptSchema.nullable(),
     })
     .strict(),
   z
diff --git a/tests/client-state.test.ts b/tests/client-state.test.ts
index 05aec1c..2f5d279 100644
--- a/tests/client-state.test.ts
+++ b/tests/client-state.test.ts
@@ -746,7 +746,7 @@ describe("client signaling recovery policy", () => {
     Object.defineProperty(authenticated, "data", {
       value: JSON.stringify({
         type: "authenticated",
-        protocol: "screener-v9",
+        protocol: "screener-v10",
         role: "viewer",
         peerId: "viewer_12345678",
         roomExpiresAt: null,
@@ -767,7 +767,7 @@ describe("client signaling recovery policy", () => {
     expect(signal.reconnect()).toBe(false);
   });
 
-  it("keeps a Host paused across reconnect until the server confirms Resume", () => {
+  it("keeps a Host paused across reconnect until an explicit Resume is sent", () => {
     vi.useFakeTimers();
     const sockets: FakeWebSocket[] = [];
     class FakeWebSocket extends EventTarget {
@@ -815,7 +815,7 @@ describe("client signaling recovery policy", () => {
       socket.dispatchEvent(new Event("open"));
       receive(socket, {
         type: "authenticated",
-        protocol: "screener-v9",
+        protocol: "screener-v10",
         role: "host",
         peerId: "host_12345678",
         roomExpiresAt: null,
@@ -843,21 +843,6 @@ describe("client signaling recovery policy", () => {
 
     signal.start();
     authenticate(sockets[0]!);
-    expect(
-      signal.confirmSharingResumed({
-        type: "sharing-resume-authorized",
-        shareGeneration: "share_generation_12345678",
-        codecGeneration: null,
-        resumeAttempt: 1,
-      }),
-    ).toBe(true);
-    expect(
-      JSON.parse(String(sockets[0]!.send.mock.calls.at(-1)![0])),
-    ).toMatchObject({
-      type: "sharing-source-enabled",
-      resumeAttempt: 1,
-    });
-
     reconnect(sockets[0]!);
     sockets[1]!.dispatchEvent(new Event("open"));
     expect(JSON.parse(String(sockets[1]!.send.mock.calls[0]![0]))).toMatchObject({
@@ -866,7 +851,7 @@ describe("client signaling recovery policy", () => {
     });
     receive(sockets[1]!, {
       type: "authenticated",
-      protocol: "screener-v9",
+      protocol: "screener-v10",
       role: "host",
       peerId: "host_12345678",
       roomExpiresAt: null,
@@ -880,9 +865,12 @@ describe("client signaling recovery policy", () => {
       codeEntryPolicy: "open",
       viewerAuthorizationGeneration: "viewer_generation_12345678",
     });
-    receive(sockets[1]!, {
-      type: "host-status",
-      online: true,
+    expect(signal.setSharingPaused(false)).toBe(true);
+    expect(
+      JSON.parse(String(sockets[1]!.send.mock.calls.at(-1)![0])),
+    ).toMatchObject({
+      type: "set-sharing-paused",
+      shareGeneration: "share_generation_12345678",
       paused: false,
     });
 
@@ -948,7 +936,7 @@ describe("client signaling recovery policy", () => {
       socket.dispatchEvent(new Event("open"));
       receive(socket, {
         type: "authenticated",
-        protocol: "screener-v9",
+        protocol: "screener-v10",
         role: "host",
         peerId: "host_12345678",
         roomExpiresAt: null,
@@ -1073,7 +1061,7 @@ describe("client signaling recovery policy", () => {
     sockets[0]!.dispatchEvent(new Event("open"));
     receive({
       type: "authenticated",
-      protocol: "screener-v9",
+      protocol: "screener-v10",
       role: "viewer",
       peerId: "viewer_12345678",
       roomExpiresAt: null,
@@ -1201,7 +1189,7 @@ describe("client signaling recovery policy", () => {
         JSON.parse(String(sockets[0]!.send.mock.calls[0]![0])),
       ).toMatchObject({
         type: "authenticate",
-        protocol: "screener-v9",
+        protocol: "screener-v10",
       });
       const message = new Event("message");
       Object.defineProperty(message, "data", { value: payload });
diff --git a/tests/codec-proof.test.ts b/tests/codec-proof.test.ts
deleted file mode 100644
index 0dec6af..0000000
--- a/tests/codec-proof.test.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  CodecProofReporter,
-  type CodecProofRouteSample,
-} from "../src/client/media/codec-proof.ts";
-import { EMPTY_METRICS } from "../src/client/types.ts";
-import type { ClientMessage, ServerMessage } from "../src/shared/protocol.ts";
-
-const request = {
-  type: "video-codec-proof-request",
-  shareGeneration: "share_generation_12345678",
-  generation: 1,
-  resumeAttempt: 3,
-  routeRevision: 7,
-  expectedCodec: "vp8",
-  binding: { kind: "peer", connectionId: "connection_12345678" },
-} satisfies Extract<ServerMessage, { type: "video-codec-proof-request" }>;
-
-function sample(
-  timestamp: number,
-  framesDecodedDelta: number | null,
-  rtpStatsId = "inbound_video_12345678",
-): CodecProofRouteSample {
-  return {
-    routeRevision: 7,
-    binding: { kind: "peer", connectionId: "connection_12345678" },
-    metrics: {
-      ...EMPTY_METRICS,
-      sampleTimestampMs: timestamp,
-      rtpStatsId,
-      rtpSsrc: 42,
-      rtpMid: "0",
-      trackIdentifier: "track_12345678",
-      intervalFramesDecoded: framesDecodedDelta,
-      codec: "video/VP8",
-    },
-  };
-}
-
-describe("CodecProofReporter", () => {
-  it("proves only a later decoded sample on the exact frozen binding", () => {
-    const sent: ClientMessage[] = [];
-    const reporter = new CodecProofReporter((message) => {
-      sent.push(message);
-      return true;
-    });
-
-    expect(reporter.request(request)).toBe(true);
-    reporter.offer(sample(100, 1));
-    reporter.offer(sample(200, 0));
-    expect(sent).toEqual([]);
-    reporter.offer(sample(300, 5));
-
-    expect(sent).toEqual([
-      expect.objectContaining({
-        type: "video-codec-proof",
-        generation: 1,
-        resumeAttempt: 3,
-        routeRevision: 7,
-        evidence: expect.objectContaining({
-          baselineSampleTimestampMs: 100,
-          sampleTimestampMs: 300,
-          framesDecodedDelta: 5,
-          actualCodec: "vp8",
-        }),
-      }),
-    ]);
-  });
-
-  it("re-baselines when the inbound RTP stats object changes", () => {
-    const send = vi.fn((_message: ClientMessage) => true);
-    const reporter = new CodecProofReporter(send);
-    reporter.request(request);
-
-    reporter.offer(sample(100, 0, "old_inbound_12345678"));
-    reporter.offer(sample(200, 1, "new_inbound_12345678"));
-    expect(send).not.toHaveBeenCalled();
-    reporter.offer(sample(300, 2, "new_inbound_12345678"));
-    expect(send).toHaveBeenCalledOnce();
-  });
-
-  it("retains a request until an exact-route baseline becomes available", () => {
-    const send = vi.fn(() => true);
-    const reporter = new CodecProofReporter(send);
-    expect(reporter.request(request)).toBe(true);
-    reporter.offer({ ...sample(150, 1), routeRevision: 8 });
-    expect(send).not.toHaveBeenCalled();
-    reporter.offer(sample(200, 0));
-    reporter.offer(sample(300, 2));
-    expect(send).toHaveBeenCalledOnce();
-  });
-
-  it("ignores out-of-order samples without replacing the current baseline", () => {
-    const send = vi.fn((_message: ClientMessage) => true);
-    const reporter = new CodecProofReporter(send);
-    reporter.request(request);
-
-    reporter.offer(sample(200, 0));
-    reporter.offer(sample(100, 1, "older_inbound_12345678"));
-    reporter.offer(sample(300, 2));
-
-    expect(send).toHaveBeenCalledOnce();
-    expect(send.mock.calls[0]?.[0]).toMatchObject({
-      type: "video-codec-proof",
-      evidence: {
-        baselineSampleTimestampMs: 200,
-        sampleTimestampMs: 300,
-      },
-    });
-  });
-
-  it("uses the first exact sample after the proof request only as a baseline", () => {
-    const send = vi.fn((_message: ClientMessage) => true);
-    const reporter = new CodecProofReporter(send);
-
-    reporter.request(request);
-    reporter.offer(sample(200, 1));
-    reporter.offer(sample(300, 0));
-    expect(send).not.toHaveBeenCalled();
-
-    reporter.offer(sample(400, 2));
-    expect(send).toHaveBeenCalledOnce();
-    expect(send.mock.calls[0]?.[0]).toMatchObject({
-      type: "video-codec-proof",
-      resumeAttempt: 3,
-      evidence: {
-        baselineSampleTimestampMs: 200,
-        sampleTimestampMs: 400,
-        framesDecodedDelta: 2,
-      },
-    });
-  });
-});
diff --git a/tests/codec-transition.test.ts b/tests/codec-transition.test.ts
deleted file mode 100644
index 0e86694..0000000
--- a/tests/codec-transition.test.ts
+++ /dev/null
@@ -1,1423 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import {
-  CodecTransitionCoordinator,
-  type CodecTransitionCoordinatorOptions,
-} from "../src/server/codec-transition.ts";
-import type {
-  CodecRouteSnapshot,
-  CodecRouteTarget,
-} from "../src/server/hybrid-media-router.ts";
-import {
-  clientMessageSchema,
-  type CodecProofEvidence,
-  type CodecTransitionGeneration,
-  type ResumeAttempt,
-  type ServerMessage,
-} from "../src/shared/protocol.ts";
-
-interface ResumeAuthorization {
-  codecGeneration: CodecTransitionGeneration | null;
-  resumeAttempt: ResumeAttempt;
-}
-
-const resumeAuthorizations = new WeakMap<
-  CodecTransitionCoordinator,
-  ResumeAuthorization[]
->();
-
-const peerTarget = (
-  viewerPeerId = "viewer_12345678",
-  viewerSessionId = "viewer_session_12345678",
-  parentSessionId = "host_session_12345678",
-  connectionId = "connection_12345678",
-): CodecRouteTarget => ({
-  viewerPeerId,
-  viewerSessionId,
-  preparationOwnerSessionId: parentSessionId,
-  preparationBinding: {
-    kind: "peer",
-    childPeerId: viewerPeerId,
-    connectionId,
-  },
-  proofBinding: { kind: "peer", connectionId },
-  routeRevision: 7,
-  proofReady: true,
-});
-
-const sfuTarget = (
-  publicationGeneration = "publication_generation_12345678",
-  connectionId = "sfu_connection_12345678",
-  routeRevision = 7,
-  proofReady = true,
-  viewerPeerId = "viewer_sfu_12345678",
-  viewerSessionId = "viewer_session_sfu_12345678",
-): CodecRouteTarget => ({
-  viewerPeerId,
-  viewerSessionId,
-  preparationOwnerSessionId: "host_session_12345678",
-  preparationBinding: {
-    kind: "sfu",
-    publicationGeneration,
-  },
-  proofBinding: {
-    kind: "sfu",
-    connectionId,
-    publicationGeneration,
-  },
-  routeRevision,
-  proofReady,
-});
-
-function deferred<T>() {
-  let resolve!: (value: T | PromiseLike<T>) => void;
-  const promise = new Promise<T>((resolvePromise) => {
-    resolve = resolvePromise;
-  });
-  return { promise, resolve };
-}
-
-const flushPromises = async () => {
-  await Promise.resolve();
-  await Promise.resolve();
-};
-
-function createHarness(
-  initialTargets: CodecRouteTarget[] = [peerTarget()],
-  options: {
-    createGeneration?: () => CodecTransitionGeneration;
-    createResumeAttempt?: () => ResumeAttempt;
-    routeWaitRevision?: number | null;
-    beginSfuReplacement?: CodecTransitionCoordinatorOptions["beginSfuReplacement"];
-    parkSfuReplacement?: CodecTransitionCoordinatorOptions["parkSfuReplacement"];
-    beginSfuProof?: CodecTransitionCoordinatorOptions["beginSfuProof"];
-    abortSfuReplacement?: CodecTransitionCoordinatorOptions["abortSfuReplacement"];
-  } = {},
-) {
-  let snapshot: CodecRouteSnapshot | null = {
-    revision: 7,
-    targets: initialTargets,
-  };
-  let nextGeneration = 1;
-  let nextResumeAttempt = 1;
-  const routeWaitRevision: number | null =
-    options.routeWaitRevision === undefined ? 9 : options.routeWaitRevision;
-  let routeWaitHandler: (() => void) | null = null;
-  const sent: Array<{ sessionId: string; message: ServerMessage }> = [];
-  const committed: string[] = [];
-  const resumes: ResumeAuthorization[] = [];
-  const confirmations: ResumeAuthorization[] = [];
-  const pauses: Array<CodecTransitionGeneration | null> = [];
-  const pauseAttempts: Array<ResumeAttempt | null> = [];
-  const releases: string[] = [];
-  const routeWaitCalls: Array<{
-    roomId: string;
-    viewerPeerIds: string[];
-  }> = [];
-  const sfuReplacementCalls: Array<
-    Parameters<CodecTransitionCoordinatorOptions["beginSfuReplacement"]>[0]
-  > = [];
-  const parkedSfuReplacements: Array<{
-    roomId: string;
-    generation: CodecTransitionGeneration;
-  }> = [];
-  const sfuProofCalls: Array<{
-    roomId: string;
-    generation: CodecTransitionGeneration;
-    timeoutMs: number;
-  }> = [];
-  const abortedSfuReplacements: Array<{
-    roomId: string;
-    generation: CodecTransitionGeneration;
-  }> = [];
-  const coordinator = new CodecTransitionCoordinator({
-    snapshot: () => snapshot,
-    sendToSession: (sessionId, message) => sent.push({ sessionId, message }),
-    commitCodec: (_roomId, codec) => committed.push(codec),
-    authorizeResume: (
-      _roomId,
-      _hostSessionId,
-      _shareGeneration,
-      codecGeneration,
-      resumeAttempt,
-    ) => resumes.push({ codecGeneration, resumeAttempt }),
-    confirmSourceEnabled: (
-      _roomId,
-      _hostSessionId,
-      _shareGeneration,
-      codecGeneration,
-      resumeAttempt,
-    ) => {
-      confirmations.push({ codecGeneration, resumeAttempt });
-      return true;
-    },
-    restoreAuthoritativePause: (
-      _roomId,
-      _hostSessionId,
-      _shareGeneration,
-      codecGeneration,
-      resumeAttempt,
-    ) => {
-      pauses.push(codecGeneration);
-      pauseAttempts.push(resumeAttempt);
-    },
-    returnTargetsToRouteWait: (roomId, viewerPeerIds) => {
-      routeWaitCalls.push({ roomId, viewerPeerIds: [...viewerPeerIds] });
-      routeWaitHandler?.();
-      return routeWaitRevision;
-    },
-    beginSfuReplacement: (input) => {
-      sfuReplacementCalls.push({ ...input });
-      return options.beginSfuReplacement?.(input) ?? Promise.resolve(null);
-    },
-    parkSfuReplacement: (roomId, generation) => {
-      parkedSfuReplacements.push({ roomId, generation });
-      return options.parkSfuReplacement?.(roomId, generation) ?? false;
-    },
-    beginSfuProof: (roomId, generation, timeoutMs) => {
-      sfuProofCalls.push({ roomId, generation, timeoutMs });
-      return options.beginSfuProof?.(roomId, generation, timeoutMs) ?? false;
-    },
-    abortSfuReplacement: (roomId, generation) => {
-      abortedSfuReplacements.push({ roomId, generation });
-      options.abortSfuReplacement?.(roomId, generation);
-    },
-    releaseRoutePause: (roomId) => releases.push(roomId),
-    timeoutMs: 100,
-    createGeneration: options.createGeneration ?? (() => nextGeneration++),
-    createResumeAttempt:
-      options.createResumeAttempt ?? (() => nextResumeAttempt++),
-  });
-  resumeAuthorizations.set(coordinator, resumes);
-  return {
-    coordinator,
-    sent,
-    committed,
-    resumes,
-    confirmations,
-    pauses,
-    pauseAttempts,
-    releases,
-    routeWaitCalls,
-    sfuReplacementCalls,
-    parkedSfuReplacements,
-    sfuProofCalls,
-    abortedSfuReplacements,
-    setSnapshot(next: CodecRouteSnapshot | null) {
-      snapshot = next;
-    },
-    setRouteWaitHandler(next: (() => void) | null) {
-      routeWaitHandler = next;
-    },
-  };
-}
-
-const start = (coordinator: CodecTransitionCoordinator) =>
-  coordinator.start({
-    roomId: "1234",
-    hostSessionId: "host_session_12345678",
-    shareGeneration: "share_generation_12345678",
-    requested: "h264",
-    previous: "vp8",
-  });
-
-const prepared = (
-  coordinator: CodecTransitionCoordinator,
-  accepted = true,
-  generation: CodecTransitionGeneration = 1,
-) =>
-  coordinator.prepared("1234", "host_session_12345678", {
-    type: "video-codec-prepared",
-    shareGeneration: "share_generation_12345678",
-    generation,
-    binding: {
-      kind: "peer",
-      childPeerId: "viewer_12345678",
-      connectionId: "connection_12345678",
-    },
-    accepted,
-  });
-
-const sfuPrepared = (
-  coordinator: CodecTransitionCoordinator,
-  publicationGeneration: string,
-  accepted = true,
-  generation: CodecTransitionGeneration = 1,
-) =>
-  coordinator.prepared("1234", "host_session_12345678", {
-    type: "video-codec-prepared",
-    shareGeneration: "share_generation_12345678",
-    generation,
-    binding: {
-      kind: "sfu",
-      publicationGeneration,
-    },
-    accepted,
-  });
-
-const requestResume = (coordinator: CodecTransitionCoordinator) =>
-  coordinator.requestResume({
-    roomId: "1234",
-    hostSessionId: "host_session_12345678",
-    shareGeneration: "share_generation_12345678",
-  });
-
-const acknowledgeLatestResume = (coordinator: CodecTransitionCoordinator) => {
-  const authorization = resumeAuthorizations.get(coordinator)?.at(-1);
-  if (!authorization) return false;
-  return coordinator.sourceEnabled({
-    roomId: "1234",
-    hostSessionId: "host_session_12345678",
-    shareGeneration: "share_generation_12345678",
-    ...authorization,
-  });
-};
-
-const resume = (coordinator: CodecTransitionCoordinator) => {
-  const result = requestResume(coordinator);
-  if (result !== "busy") {
-    acknowledgeLatestResume(coordinator);
-  }
-  return result;
-};
-
-const latestResumeAttempt = (coordinator: CodecTransitionCoordinator) =>
-  resumeAuthorizations.get(coordinator)?.at(-1)?.resumeAttempt ?? 1;
-
-const proofEvidence = (
-  actualCodec: CodecProofEvidence["actualCodec"],
-  overrides: Partial<CodecProofEvidence> = {},
-): CodecProofEvidence => ({
-  baselineSampleTimestampMs: 100,
-  sampleTimestampMs: 200,
-  rtpStatsId: "inbound_rtp_1",
-  rtpSsrc: 1_234,
-  rtpMid: "0",
-  rtpRid: null,
-  trackIdentifier: "remote_video_track_1",
-  framesDecodedDelta: 1,
-  actualCodec,
-  ...overrides,
-});
-
-const proof = (
-  coordinator: CodecTransitionCoordinator,
-  actualCodec: CodecProofEvidence["actualCodec"],
-  options: {
-    generation?: CodecTransitionGeneration;
-    resumeAttempt?: ResumeAttempt;
-    routeRevision?: number;
-    evidence?: Partial<CodecProofEvidence>;
-  } = {},
-) =>
-  coordinator.proof("1234", "viewer_session_12345678", {
-    type: "video-codec-proof",
-    shareGeneration: "share_generation_12345678",
-    generation: options.generation ?? 1,
-    resumeAttempt:
-      options.resumeAttempt ?? latestResumeAttempt(coordinator),
-    routeRevision: options.routeRevision ?? 7,
-    binding: { kind: "peer", connectionId: "connection_12345678" },
-    evidence: proofEvidence(actualCodec, options.evidence),
-  });
-
-const sfuProof = (
-  coordinator: CodecTransitionCoordinator,
-  actualCodec: CodecProofEvidence["actualCodec"],
-  publicationGeneration: string,
-  connectionId: string,
-  options: {
-    generation?: CodecTransitionGeneration;
-    resumeAttempt?: ResumeAttempt;
-    routeRevision?: number;
-    evidence?: Partial<CodecProofEvidence>;
-  } = {},
-) =>
-  coordinator.proof("1234", "viewer_session_sfu_12345678", {
-    type: "video-codec-proof",
-    shareGeneration: "share_generation_12345678",
-    generation: options.generation ?? 1,
-    resumeAttempt:
-      options.resumeAttempt ?? latestResumeAttempt(coordinator),
-    routeRevision: options.routeRevision ?? 7,
-    binding: {
-      kind: "sfu",
-      connectionId,
-      publicationGeneration,
-    },
-    evidence: proofEvidence(actualCodec, options.evidence),
-  });
-
-describe("CodecTransitionCoordinator", () => {
-  beforeEach(() => vi.useFakeTimers());
-
-  afterEach(() => {
-    vi.clearAllTimers();
-    vi.useRealTimers();
-  });
-
-  it("waits without a timer after preparation and commits only after decoded proof", () => {
-    const harness = createHarness();
-
-    expect(start(harness.coordinator)).toBe("started");
-    expect(harness.sent.at(-1)?.message.type).toBe("video-codec-prepare");
-    prepared(harness.coordinator);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      status: "prepared",
-      videoCodec: "h264",
-    });
-
-    vi.advanceTimersByTime(10_000);
-    expect(harness.committed).toEqual([]);
-    expect(harness.pauses).toEqual([]);
-
-    expect(resume(harness.coordinator)).toBe("started-proof");
-    expect(harness.resumes).toEqual([
-      { codecGeneration: 1, resumeAttempt: 1 },
-    ]);
-    expect(harness.releases).toEqual([]);
-    proof(harness.coordinator, "h264");
-
-    expect(harness.committed).toEqual(["h264"]);
-    expect(harness.releases).toEqual(["1234"]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      status: "committed",
-      failure: null,
-    });
-  });
-
-  it("keeps the room paused and withholds proof until the exact source ack", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-
-    expect(requestResume(harness.coordinator)).toBe("started-proof");
-    expect(harness.confirmations).toEqual([]);
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-proof-request",
-      ),
-    ).toEqual([]);
-    expect(
-      harness.coordinator.sourceEnabled({
-        roomId: "1234",
-        hostSessionId: "host_session_12345678",
-        shareGeneration: "share_generation_12345678",
-        codecGeneration: 1,
-        resumeAttempt: 2,
-      }),
-    ).toBe(false);
-
-    expect(acknowledgeLatestResume(harness.coordinator)).toBe(true);
-    expect(harness.confirmations).toEqual([
-      { codecGeneration: 1, resumeAttempt: 1 },
-    ]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-proof-request",
-      generation: 1,
-      resumeAttempt: 1,
-    });
-
-    proof(harness.coordinator, "h264", { resumeAttempt: 2 });
-    expect(harness.committed).toEqual([]);
-    proof(harness.coordinator, "h264");
-    expect(harness.committed).toEqual(["h264"]);
-  });
-
-  it("invalidates an old source ack and proof when Pause opens a new attempt", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-    requestResume(harness.coordinator);
-    const first = harness.resumes.at(-1)!;
-
-    harness.coordinator.pause({
-      roomId: "1234",
-      hostSessionId: "host_session_12345678",
-      shareGeneration: "share_generation_12345678",
-    });
-    expect(
-      harness.coordinator.sourceEnabled({
-        roomId: "1234",
-        hostSessionId: "host_session_12345678",
-        shareGeneration: "share_generation_12345678",
-        ...first,
-      }),
-    ).toBe(false);
-
-    requestResume(harness.coordinator);
-    const second = harness.resumes.at(-1)!;
-    expect(second.resumeAttempt).toBeGreaterThan(first.resumeAttempt);
-    expect(acknowledgeLatestResume(harness.coordinator)).toBe(true);
-    proof(harness.coordinator, "h264", {
-      resumeAttempt: first.resumeAttempt,
-    });
-    expect(harness.committed).toEqual([]);
-    proof(harness.coordinator, "h264");
-    expect(harness.committed).toEqual(["h264"]);
-  });
-
-  it("bounds an ordinary Resume ack and permits a later retry", () => {
-    const harness = createHarness([]);
-
-    expect(requestResume(harness.coordinator)).toBe("normal");
-    expect(harness.releases).toEqual([]);
-    vi.advanceTimersByTime(100);
-    expect(harness.pauses).toEqual([null]);
-    expect(harness.pauseAttempts).toEqual([1]);
-    expect(harness.releases).toEqual([]);
-
-    expect(requestResume(harness.coordinator)).toBe("normal");
-    expect(harness.resumes.at(-1)).toEqual({
-      codecGeneration: null,
-      resumeAttempt: 2,
-    });
-    expect(acknowledgeLatestResume(harness.coordinator)).toBe(true);
-    expect(harness.releases).toEqual(["1234"]);
-  });
-
-  it("invalidates an ordinary Resume across a Host session replacement", () => {
-    const harness = createHarness([]);
-    requestResume(harness.coordinator);
-
-    harness.coordinator.invalidateHostSession(
-      "1234",
-      "host_session_reconnected_12345678",
-    );
-
-    expect(harness.pauses).toEqual([null]);
-    expect(harness.pauseAttempts).toEqual([null]);
-    expect(acknowledgeLatestResume(harness.coordinator)).toBe(false);
-    expect(harness.releases).toEqual([]);
-  });
-
-  it("uses one Resume deadline across source ack and proof", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-    requestResume(harness.coordinator);
-
-    vi.advanceTimersByTime(90);
-    expect(acknowledgeLatestResume(harness.coordinator)).toBe(true);
-    vi.advanceTimersByTime(10);
-
-    expect(harness.pauses).toEqual([1]);
-    expect(harness.pauseAttempts).toEqual([1]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-prepare",
-      generation: 2,
-      videoCodec: "vp8",
-    });
-  });
-
-  it("continues the same generation when a pending SFU target has left", async () => {
-    const replacement = deferred<CodecRouteSnapshot | null>();
-    const direct = peerTarget();
-    const harness = createHarness(
-      [direct, sfuTarget("publication_generation_old_12345678")],
-      { beginSfuReplacement: () => replacement.promise },
-    );
-    start(harness.coordinator);
-
-    harness.setSnapshot({
-      revision: 8,
-      targets: [{ ...direct, routeRevision: 8 }],
-    });
-    replacement.resolve(null);
-    await flushPromises();
-
-    expect(harness.abortedSfuReplacements).toEqual([
-      { roomId: "1234", generation: 1 },
-    ]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-prepare",
-      generation: 1,
-      videoCodec: "h264",
-    });
-    expect(harness.sfuReplacementCalls).toHaveLength(1);
-  });
-
-  it("recomputes SFU need from the current snapshot for rollback", () => {
-    const never = () => new Promise<CodecRouteSnapshot | null>(() => undefined);
-    const direct = peerTarget();
-    const harness = createHarness(
-      [sfuTarget("publication_generation_old_12345678")],
-      { beginSfuReplacement: never },
-    );
-    start(harness.coordinator);
-    harness.setSnapshot({ revision: 8, targets: [direct] });
-
-    vi.advanceTimersByTime(100);
-
-    expect(harness.sfuReplacementCalls).toHaveLength(1);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-prepare",
-      generation: 2,
-      videoCodec: "vp8",
-    });
-  });
-
-  it("parks a fresh SFU publication and gates proof until its route is ready", async () => {
-    const oldPublication = "publication_generation_old_12345678";
-    const freshPublication = "publication_generation_h264_12345678";
-    const freshConnection = "sfu_connection_h264_12345678";
-    const replacement = deferred<CodecRouteSnapshot | null>();
-    const harness = createHarness([sfuTarget(oldPublication)], {
-      beginSfuReplacement: () => replacement.promise,
-      parkSfuReplacement: () => true,
-      beginSfuProof: () => true,
-    });
-
-    expect(start(harness.coordinator)).toBe("started");
-    expect(harness.sfuReplacementCalls).toEqual([
-      {
-        roomId: "1234",
-        hostSessionId: "host_session_12345678",
-        generation: 1,
-        videoCodec: "h264",
-        timeoutMs: 100,
-      },
-    ]);
-    expect(harness.sent).toEqual([]);
-
-    const freshPending = sfuTarget(
-      freshPublication,
-      freshConnection,
-      8,
-      false,
-    );
-    const freshSnapshot = { revision: 8, targets: [freshPending] };
-    harness.setSnapshot(freshSnapshot);
-    replacement.resolve(freshSnapshot);
-    await flushPromises();
-
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-prepare",
-      ),
-    ).toEqual([]);
-    sfuPrepared(harness.coordinator, freshPublication);
-    expect(harness.parkedSfuReplacements).toEqual([
-      { roomId: "1234", generation: 1 },
-    ]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      generation: 1,
-      status: "prepared",
-    });
-
-    vi.advanceTimersByTime(10_000);
-    expect(harness.sfuReplacementCalls).toHaveLength(1);
-    expect(harness.abortedSfuReplacements).toEqual([]);
-    expect(harness.committed).toEqual([]);
-
-    expect(resume(harness.coordinator)).toBe("started-proof");
-    expect(harness.sfuProofCalls).toEqual([
-      { roomId: "1234", generation: 1, timeoutMs: 100 },
-    ]);
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-proof-request",
-      ),
-    ).toEqual([]);
-
-    harness.setSnapshot({
-      revision: 9,
-      targets: [{ ...freshPending, routeRevision: 9, proofReady: true }],
-    });
-    harness.coordinator.participantChanged("1234");
-    expect(harness.sent.at(-1)).toMatchObject({
-      sessionId: "viewer_session_sfu_12345678",
-      message: {
-        type: "video-codec-proof-request",
-        generation: 1,
-        routeRevision: 9,
-        binding: {
-          kind: "sfu",
-          connectionId: freshConnection,
-          publicationGeneration: freshPublication,
-        },
-      },
-    });
-
-    sfuProof(
-      harness.coordinator,
-      "h264",
-      freshPublication,
-      freshConnection,
-      { routeRevision: 9 },
-    );
-    expect(harness.committed).toEqual(["h264"]);
-    expect(harness.releases).toEqual(["1234"]);
-  });
-
-  it("starts rollback with another fresh SFU generation after proof failure", async () => {
-    const replacements = [
-      deferred<CodecRouteSnapshot | null>(),
-      deferred<CodecRouteSnapshot | null>(),
-    ];
-    let replacementIndex = 0;
-    const harness = createHarness(
-      [sfuTarget("publication_generation_old_12345678")],
-      {
-        beginSfuReplacement: () =>
-          replacements[replacementIndex++]!.promise,
-        parkSfuReplacement: () => true,
-        beginSfuProof: () => true,
-      },
-    );
-
-    start(harness.coordinator);
-    const requestedPending = sfuTarget(
-      "publication_generation_h264_12345678",
-      "sfu_connection_h264_12345678",
-      8,
-      false,
-    );
-    const requestedSnapshot = { revision: 8, targets: [requestedPending] };
-    harness.setSnapshot(requestedSnapshot);
-    replacements[0]!.resolve(requestedSnapshot);
-    await flushPromises();
-    sfuPrepared(
-      harness.coordinator,
-      "publication_generation_h264_12345678",
-    );
-    resume(harness.coordinator);
-    harness.setSnapshot({
-      revision: 9,
-      targets: [{ ...requestedPending, routeRevision: 9, proofReady: true }],
-    });
-    harness.coordinator.participantChanged("1234");
-
-    sfuProof(
-      harness.coordinator,
-      "vp8",
-      "publication_generation_h264_12345678",
-      "sfu_connection_h264_12345678",
-      { routeRevision: 9 },
-    );
-    expect(harness.pauses).toEqual([1]);
-    expect(harness.sfuReplacementCalls.map((call) => call.generation)).toEqual([
-      1, 2,
-    ]);
-    expect(harness.sfuReplacementCalls.at(-1)).toMatchObject({
-      generation: 2,
-      videoCodec: "vp8",
-    });
-    expect(harness.resumes).toHaveLength(1);
-
-    const rollbackPending = sfuTarget(
-      "publication_generation_rollback_12345678",
-      "sfu_connection_rollback_12345678",
-      10,
-      false,
-    );
-    const rollbackSnapshot = { revision: 10, targets: [rollbackPending] };
-    harness.setSnapshot(rollbackSnapshot);
-    replacements[1]!.resolve(rollbackSnapshot);
-    await flushPromises();
-    sfuPrepared(
-      harness.coordinator,
-      "publication_generation_rollback_12345678",
-      true,
-      2,
-    );
-    expect(harness.parkedSfuReplacements).toEqual([
-      { roomId: "1234", generation: 1 },
-      { roomId: "1234", generation: 2 },
-    ]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      generation: 2,
-      status: "rollback-prepared",
-      failure: "proof-failed",
-    });
-    expect(harness.resumes).toHaveLength(1);
-
-    expect(resume(harness.coordinator)).toBe("started-proof");
-    harness.setSnapshot({
-      revision: 11,
-      targets: [{ ...rollbackPending, routeRevision: 11, proofReady: true }],
-    });
-    harness.coordinator.participantChanged("1234");
-    sfuProof(
-      harness.coordinator,
-      "vp8",
-      "publication_generation_rollback_12345678",
-      "sfu_connection_rollback_12345678",
-      { generation: 2, routeRevision: 11 },
-    );
-
-    expect(harness.committed).toEqual(["vp8"]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      generation: 2,
-      status: "committed",
-      failure: "proof-failed",
-    });
-  });
-
-  it("bounds SFU initialization while leaving a parked preparation timerless", async () => {
-    const parkedReplacement = deferred<CodecRouteSnapshot | null>();
-    const parkedHarness = createHarness(
-      [sfuTarget("publication_generation_old_12345678")],
-      {
-        beginSfuReplacement: () => parkedReplacement.promise,
-        parkSfuReplacement: () => true,
-      },
-    );
-    start(parkedHarness.coordinator);
-    const freshPending = sfuTarget(
-      "publication_generation_parked_12345678",
-      "sfu_connection_parked_12345678",
-      8,
-      false,
-    );
-    const freshSnapshot = { revision: 8, targets: [freshPending] };
-    parkedHarness.setSnapshot(freshSnapshot);
-    parkedReplacement.resolve(freshSnapshot);
-    await flushPromises();
-    sfuPrepared(
-      parkedHarness.coordinator,
-      "publication_generation_parked_12345678",
-    );
-    vi.advanceTimersByTime(10_000);
-    expect(parkedHarness.sfuReplacementCalls).toHaveLength(1);
-    expect(parkedHarness.abortedSfuReplacements).toEqual([]);
-    expect(parkedHarness.coordinator.blocksResume("1234")).toBe(true);
-
-    const never = () => new Promise<CodecRouteSnapshot | null>(() => undefined);
-    const boundedHarness = createHarness(
-      [sfuTarget("publication_generation_old_12345678")],
-      { beginSfuReplacement: never },
-    );
-    start(boundedHarness.coordinator);
-    vi.advanceTimersByTime(100);
-    expect(
-      boundedHarness.sfuReplacementCalls.map((call) => ({
-        generation: call.generation,
-        videoCodec: call.videoCodec,
-      })),
-    ).toEqual([
-      { generation: 1, videoCodec: "h264" },
-      { generation: 2, videoCodec: "vp8" },
-    ]);
-    expect(boundedHarness.abortedSfuReplacements).toEqual([
-      { roomId: "1234", generation: 1 },
-    ]);
-
-    vi.advanceTimersByTime(100);
-    expect(boundedHarness.abortedSfuReplacements).toEqual([
-      { roomId: "1234", generation: 1 },
-      { roomId: "1234", generation: 2 },
-    ]);
-    expect(boundedHarness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      generation: 2,
-      status: "failed",
-      failure: "rollback-failed",
-    });
-  });
-
-  it("retires a target that is no longer proof-ready before issuing proof", () => {
-    const target = peerTarget();
-    const harness = createHarness([target]);
-
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-    expect(requestResume(harness.coordinator)).toBe("started-proof");
-
-    harness.setSnapshot({
-      revision: 8,
-      targets: [{ ...target, routeRevision: 8, proofReady: false }],
-    });
-    harness.coordinator.participantChanged("1234");
-    expect(acknowledgeLatestResume(harness.coordinator)).toBe(true);
-
-    expect(harness.routeWaitCalls).toEqual([
-      { roomId: "1234", viewerPeerIds: ["viewer_12345678"] },
-    ]);
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-proof-request",
-      ),
-    ).toEqual([]);
-    expect(harness.committed).toEqual(["h264"]);
-    expect(harness.releases).toEqual(["1234"]);
-
-    vi.advanceTimersByTime(10_000);
-    expect(harness.pauses).toEqual([]);
-  });
-
-  it("removes an invalid SFU anchor from proof without starting rollback", async () => {
-    const replacement = deferred<CodecRouteSnapshot | null>();
-    const direct = peerTarget();
-    const harness = createHarness(
-      [direct, sfuTarget("publication_generation_old_12345678")],
-      {
-        beginSfuReplacement: () => replacement.promise,
-        parkSfuReplacement: () => true,
-        beginSfuProof: () => true,
-      },
-    );
-
-    start(harness.coordinator);
-    const retainedDirect = { ...direct, routeRevision: 8 };
-    const pendingAnchor = sfuTarget(
-      "publication_generation_h264_12345678",
-      "sfu_connection_h264_12345678",
-      8,
-      false,
-    );
-    const freshSnapshot = {
-      revision: 8,
-      targets: [retainedDirect, pendingAnchor],
-    };
-    harness.setSnapshot(freshSnapshot);
-    replacement.resolve(freshSnapshot);
-    await flushPromises();
-    prepared(harness.coordinator);
-    sfuPrepared(
-      harness.coordinator,
-      "publication_generation_h264_12345678",
-    );
-    expect(resume(harness.coordinator)).toBe("started-proof");
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-proof-request",
-      ),
-    ).toEqual([]);
-
-    harness.setSnapshot({
-      revision: 9,
-      targets: [{ ...retainedDirect, routeRevision: 9 }],
-    });
-    harness.coordinator.participantChanged("1234");
-    expect(harness.routeWaitCalls).toEqual([
-      { roomId: "1234", viewerPeerIds: ["viewer_sfu_12345678"] },
-    ]);
-    expect(harness.abortedSfuReplacements).toEqual([
-      { roomId: "1234", generation: 1 },
-    ]);
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-proof-request",
-      ),
-    ).toEqual([
-      expect.objectContaining({
-        sessionId: "viewer_session_12345678",
-        message: expect.objectContaining({
-          generation: 1,
-          routeRevision: 9,
-          binding: {
-            kind: "peer",
-            connectionId: "connection_12345678",
-          },
-        }),
-      }),
-    ]);
-
-    proof(harness.coordinator, "h264", { routeRevision: 9 });
-    expect(harness.committed).toEqual(["h264"]);
-    expect(harness.pauses).toEqual([]);
-    expect(harness.sfuReplacementCalls).toHaveLength(1);
-    expect(
-      harness.sent.some(
-        ({ message }) =>
-          message.type === "video-codec-result" &&
-          (message.status === "rollback-prepared" ||
-            message.status === "failed"),
-      ),
-    ).toBe(false);
-  });
-
-  it("routes non-ready targets outside the pending SFU subtree to wait immediately", async () => {
-    const replacement = deferred<CodecRouteSnapshot | null>();
-    const retainedAnchorChild = peerTarget(
-      "viewer_anchor_child_12345678",
-      "viewer_session_anchor_child_12345678",
-      "viewer_session_sfu_anchor_12345678",
-      "connection_anchor_child_12345678",
-    );
-    const retainedAnchorGrandchild = peerTarget(
-      "viewer_anchor_grandchild_12345678",
-      "viewer_session_anchor_grandchild_12345678",
-      "viewer_session_anchor_child_12345678",
-      "connection_anchor_grandchild_12345678",
-    );
-    const unreachableOtherRootChild = {
-      ...peerTarget(
-        "viewer_other_child_12345678",
-        "viewer_session_other_child_12345678",
-        "viewer_session_sfu_other_12345678",
-        "connection_other_child_12345678",
-      ),
-      proofReady: false,
-    };
-    const harness = createHarness(
-      [
-        sfuTarget(
-          "publication_generation_old_12345678",
-          "sfu_connection_anchor_old_12345678",
-          7,
-          true,
-          "viewer_sfu_anchor_12345678",
-          "viewer_session_sfu_anchor_12345678",
-        ),
-        sfuTarget(
-          "publication_generation_old_12345678",
-          "sfu_connection_other_old_12345678",
-          7,
-          true,
-          "viewer_sfu_other_12345678",
-          "viewer_session_sfu_other_12345678",
-        ),
-        retainedAnchorChild,
-        retainedAnchorGrandchild,
-        { ...unreachableOtherRootChild, proofReady: true },
-      ],
-      {
-        beginSfuReplacement: () => replacement.promise,
-        parkSfuReplacement: () => true,
-        beginSfuProof: () => true,
-      },
-    );
-
-    start(harness.coordinator);
-    const freshAnchor = sfuTarget(
-      "publication_generation_h264_12345678",
-      "sfu_connection_anchor_h264_12345678",
-      8,
-      false,
-      "viewer_sfu_anchor_12345678",
-      "viewer_session_sfu_anchor_12345678",
-    );
-    const preparedSnapshot = {
-      revision: 8,
-      targets: [
-        freshAnchor,
-        { ...retainedAnchorChild, routeRevision: 8, proofReady: false },
-        {
-          ...retainedAnchorGrandchild,
-          routeRevision: 8,
-          proofReady: false,
-        },
-        { ...unreachableOtherRootChild, routeRevision: 8 },
-      ],
-    };
-    harness.setSnapshot(preparedSnapshot);
-    replacement.resolve(preparedSnapshot);
-    await flushPromises();
-    for (const target of preparedSnapshot.targets) {
-      if (target.preparationBinding.kind !== "peer") continue;
-      harness.coordinator.prepared("1234", target.preparationOwnerSessionId, {
-        type: "video-codec-prepared",
-        shareGeneration: "share_generation_12345678",
-        generation: 1,
-        binding: target.preparationBinding,
-        accepted: true,
-      });
-    }
-    sfuPrepared(
-      harness.coordinator,
-      "publication_generation_h264_12345678",
-    );
-    expect(resume(harness.coordinator)).toBe("started-proof");
-    expect(harness.routeWaitCalls).toEqual([
-      {
-        roomId: "1234",
-        viewerPeerIds: ["viewer_other_child_12345678"],
-      },
-    ]);
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-proof-request",
-      ),
-    ).toEqual([]);
-
-    harness.setSnapshot({
-      revision: 9,
-      targets: [
-        { ...freshAnchor, routeRevision: 9, proofReady: true },
-        { ...retainedAnchorChild, routeRevision: 9, proofReady: true },
-        {
-          ...retainedAnchorGrandchild,
-          routeRevision: 9,
-          proofReady: true,
-        },
-        { ...unreachableOtherRootChild, routeRevision: 9 },
-      ],
-    });
-    harness.coordinator.participantChanged("1234");
-
-    expect(harness.routeWaitCalls).toEqual([
-      {
-        roomId: "1234",
-        viewerPeerIds: ["viewer_other_child_12345678"],
-      },
-    ]);
-    expect(
-      harness.sent
-        .filter(({ message }) => message.type === "video-codec-proof-request")
-        .map(({ sessionId }) => sessionId),
-    ).toEqual([
-      "viewer_session_sfu_anchor_12345678",
-      "viewer_session_anchor_child_12345678",
-      "viewer_session_anchor_grandchild_12345678",
-    ]);
-    expect(harness.pauses).toEqual([]);
-  });
-
-  it("rolls back an actual-codec mismatch and waits for another user resume", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-    resume(harness.coordinator);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-proof-request",
-      generation: 1,
-      expectedCodec: "h264",
-    });
-
-    proof(harness.coordinator, "vp8");
-    expect(harness.pauses).toEqual([1]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-prepare",
-      generation: 2,
-      videoCodec: "vp8",
-    });
-    expect(harness.resumes).toHaveLength(1);
-
-    prepared(harness.coordinator, true, 2);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      status: "rollback-prepared",
-      failure: "proof-failed",
-    });
-    vi.advanceTimersByTime(10_000);
-    expect(harness.resumes).toHaveLength(1);
-    expect(harness.committed).toEqual([]);
-
-    resume(harness.coordinator);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-proof-request",
-      generation: 2,
-      expectedCodec: null,
-    });
-    proof(harness.coordinator, "vp8", { generation: 2 });
-    expect(harness.committed).toEqual(["vp8"]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      status: "committed",
-      videoCodec: "vp8",
-      failure: "proof-failed",
-    });
-  });
-
-  it("accepts a different actual codec after exact rollback preparation", () => {
-    const harness = createHarness();
-    expect(
-      harness.coordinator.start({
-        roomId: "1234",
-        hostSessionId: "host_session_12345678",
-        shareGeneration: "share_generation_12345678",
-        requested: "vp8",
-        previous: "h264",
-      }),
-    ).toBe("started");
-    prepared(harness.coordinator);
-    resume(harness.coordinator);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-proof-request",
-      generation: 1,
-      expectedCodec: "vp8",
-    });
-
-    proof(harness.coordinator, "h264");
-    expect(harness.pauses).toEqual([1]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-prepare",
-      generation: 2,
-      videoCodec: "h264",
-    });
-    prepared(harness.coordinator, true, 2);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      status: "rollback-prepared",
-      failure: "proof-failed",
-    });
-
-    resume(harness.coordinator);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-proof-request",
-      generation: 2,
-      expectedCodec: null,
-    });
-    proof(harness.coordinator, "vp8", { generation: 2 });
-
-    expect(harness.committed).toEqual(["h264"]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      generation: 2,
-      status: "committed",
-      videoCodec: "h264",
-      failure: "proof-failed",
-    });
-  });
-
-  it("returns a user-paused proof to the prepared state", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-    resume(harness.coordinator);
-
-    harness.coordinator.pause({
-      roomId: "1234",
-      hostSessionId: "host_session_12345678",
-      shareGeneration: "share_generation_12345678",
-    });
-    vi.advanceTimersByTime(10_000);
-    expect(harness.pauses).toEqual([]);
-    expect(harness.committed).toEqual([]);
-
-    expect(resume(harness.coordinator)).toBe("started-proof");
-    proof(harness.coordinator, "h264");
-    expect(harness.committed).toEqual(["h264"]);
-  });
-
-  it("removes invalidated bindings and leaves routing to rebuild after commit", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    harness.setSnapshot({ revision: 8, targets: [] });
-    harness.coordinator.participantChanged("1234");
-
-    expect(harness.routeWaitCalls).toEqual([
-      { roomId: "1234", viewerPeerIds: ["viewer_12345678"] },
-    ]);
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      status: "committed",
-    });
-    expect(harness.committed).toEqual(["h264"]);
-    expect(resume(harness.coordinator)).toBe("normal");
-    expect(harness.resumes).toEqual([
-      { codecGeneration: null, resumeAttempt: 1 },
-    ]);
-    expect(harness.releases).toEqual(["1234"]);
-  });
-
-  it("batch-retires invalid bindings, rebases proof, and defers synchronous reentry", () => {
-    const retained = peerTarget();
-    const removedA = peerTarget(
-      "viewer_removed_a_12345678",
-      "viewer_session_removed_a_12345678",
-      "host_session_12345678",
-      "connection_removed_a_12345678",
-    );
-    const removedB = peerTarget(
-      "viewer_removed_b_12345678",
-      "viewer_session_removed_b_12345678",
-      "host_session_12345678",
-      "connection_removed_b_12345678",
-    );
-    const harness = createHarness([retained, removedA, removedB]);
-    start(harness.coordinator);
-    harness.setSnapshot({
-      revision: 8,
-      targets: [{ ...retained, routeRevision: 8 }],
-    });
-    harness.setRouteWaitHandler(() => {
-      harness.setSnapshot({
-        revision: 9,
-        targets: [{ ...retained, routeRevision: 9 }],
-      });
-      harness.coordinator.participantChanged("1234");
-    });
-
-    harness.coordinator.participantChanged("1234");
-
-    expect(harness.routeWaitCalls).toEqual([
-      {
-        roomId: "1234",
-        viewerPeerIds: [
-          "viewer_removed_a_12345678",
-          "viewer_removed_b_12345678",
-        ],
-      },
-    ]);
-    prepared(harness.coordinator);
-    expect(resume(harness.coordinator)).toBe("started-proof");
-    expect(
-      harness.sent.filter(
-        ({ message }) => message.type === "video-codec-proof-request",
-      ),
-    ).toEqual([
-      expect.objectContaining({
-        sessionId: "viewer_session_12345678",
-        message: expect.objectContaining({
-          routeRevision: 9,
-          generation: 1,
-        }),
-      }),
-    ]);
-
-    proof(harness.coordinator, "h264", { routeRevision: 9 });
-    expect(harness.committed).toEqual(["h264"]);
-  });
-
-  it("allocates increasing generations and rejects a duplicate allocator value", () => {
-    const harness = createHarness([]);
-
-    expect(start(harness.coordinator)).toBe("committed");
-    expect(
-      harness.coordinator.start({
-        roomId: "5678",
-        hostSessionId: "host_session_12345678",
-        shareGeneration: "share_generation_12345678",
-        requested: "h264",
-        previous: "vp8",
-      }),
-    ).toBe("committed");
-    expect(
-      harness.sent
-        .map(({ message }) => message)
-        .filter((message) => message.type === "video-codec-result")
-        .map((message) => message.generation),
-    ).toEqual([1, 2]);
-
-    const duplicate = createHarness([], { createGeneration: () => 1 });
-    expect(start(duplicate.coordinator)).toBe("committed");
-    expect(() =>
-      duplicate.coordinator.start({
-        roomId: "5678",
-        hostSessionId: "host_session_12345678",
-        shareGeneration: "share_generation_12345678",
-        requested: "h264",
-        previous: "vp8",
-      }),
-    ).toThrow("Codec transition generation must increase monotonically");
-  });
-
-  it("rejects a non-increasing Resume attempt across rooms", () => {
-    const harness = createHarness([], { createResumeAttempt: () => 1 });
-    expect(requestResume(harness.coordinator)).toBe("normal");
-
-    expect(() =>
-      harness.coordinator.requestResume({
-        roomId: "5678",
-        hostSessionId: "host_session_other_12345678",
-        shareGeneration: "share_generation_other_12345678",
-      }),
-    ).toThrow("Resume attempt must increase monotonically");
-  });
-
-  it("accepts only proof evidence sampled after a positive decoded-frame delta", () => {
-    const message = {
-      type: "video-codec-proof" as const,
-      shareGeneration: "share_generation_12345678",
-      generation: 1,
-      resumeAttempt: 1,
-      routeRevision: 7,
-      binding: { kind: "peer" as const, connectionId: "connection_12345678" },
-      evidence: proofEvidence("h264"),
-    };
-
-    expect(clientMessageSchema.safeParse(message).success).toBe(true);
-    expect(
-      clientMessageSchema.safeParse({
-        ...message,
-        evidence: proofEvidence("h264", {
-          baselineSampleTimestampMs: 200,
-          sampleTimestampMs: 200,
-        }),
-      }).success,
-    ).toBe(false);
-    expect(
-      clientMessageSchema.safeParse({
-        ...message,
-        evidence: proofEvidence("h264", { framesDecodedDelta: 0 }),
-      }).success,
-    ).toBe(false);
-  });
-
-  it("updates only the future preference when no route target exists", () => {
-    const harness = createHarness([]);
-
-    expect(start(harness.coordinator)).toBe("committed");
-    expect(harness.committed).toEqual(["h264"]);
-    expect(harness.resumes).toEqual([]);
-    expect(harness.releases).toEqual([]);
-  });
-
-  it("keeps a failed rollback as a timerless resume blocker", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-    resume(harness.coordinator);
-    proof(harness.coordinator, "vp8");
-    prepared(harness.coordinator, false, 2);
-
-    expect(harness.sent.at(-1)?.message).toMatchObject({
-      type: "video-codec-result",
-      status: "failed",
-      failure: "rollback-failed",
-    });
-    vi.advanceTimersByTime(10_000);
-    expect(resume(harness.coordinator)).toBe("busy");
-    expect(harness.releases).toEqual([]);
-    expect(harness.coordinator.blocksResume("1234")).toBe(true);
-  });
-
-  it("invalidates a transaction across a host session boundary", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-
-    harness.coordinator.invalidateHostSession(
-      "1234",
-      "host_session_reconnected_12345678",
-    );
-
-    expect(harness.pauses).toEqual([1]);
-    expect(harness.sent.at(-1)).toMatchObject({
-      sessionId: "host_session_reconnected_12345678",
-      message: {
-        type: "video-codec-result",
-        status: "failed",
-        failure: "stale-binding",
-      },
-    });
-    expect(
-      harness.coordinator.requestResume({
-        roomId: "1234",
-        hostSessionId: "host_session_reconnected_12345678",
-        shareGeneration: "share_generation_12345678",
-      }),
-    ).toBe("busy");
-    expect(harness.releases).toEqual([]);
-  });
-
-  it("repauses a proving transaction on reconnect and ignores its delayed proof", () => {
-    const harness = createHarness();
-    start(harness.coordinator);
-    prepared(harness.coordinator);
-    expect(requestResume(harness.coordinator)).toBe("started-proof");
-    expect(acknowledgeLatestResume(harness.coordinator)).toBe(true);
-    const staleResumeAttempt = latestResumeAttempt(harness.coordinator);
-
-    harness.coordinator.invalidateHostSession(
-      "1234",
-      "host_session_reconnected_12345678",
-    );
-
-    expect(harness.pauses).toEqual([1]);
-    expect(harness.pauseAttempts).toEqual([null]);
-    proof(harness.coordinator, "h264", {
-      resumeAttempt: staleResumeAttempt,
-    });
-    expect(harness.committed).toEqual([]);
-    expect(harness.releases).toEqual([]);
-    expect(harness.coordinator.blocksResume("1234")).toBe(true);
-  });
-});
diff --git a/tests/host-page-notice.test.ts b/tests/host-page-notice.test.ts
index a3514a8..1bd7650 100644
--- a/tests/host-page-notice.test.ts
+++ b/tests/host-page-notice.test.ts
@@ -5,7 +5,6 @@ import {
   hostServerErrorNotice,
   shouldPauseLocalPreview,
   sourceSwitchNotice,
-  VIDEO_CODEC_TRANSITION_FAILED_NOTICE,
   videoCodecLockNotice,
 } from "../src/client/pages/host-page-notices.ts";
 
@@ -97,22 +96,14 @@ describe("sourceSwitchNotice", () => {
 });
 
 describe("videoCodecLockNotice", () => {
-  it("exposes codec switching only after the active share is paused", () => {
-    expect(videoCodecLockNotice("starting", false)).toBe(
-      "分享开始后，暂停分享即可切换视频编码",
-    );
-    expect(videoCodecLockNotice("live", false)).toBe(
-      "暂停分享后可切换视频编码",
-    );
-    expect(videoCodecLockNotice("live", true)).toBeNull();
+  it("keeps codec selection pre-share only", () => {
+    for (const phase of ["starting", "live"]) {
+      expect(videoCodecLockNotice(phase)).toBe(
+        "本次分享的视频编码已固定，停止分享后可更改",
+      );
+    }
     for (const phase of ["idle", "ended", "error"]) {
-      expect(videoCodecLockNotice(phase, false)).toBeNull();
+      expect(videoCodecLockNotice(phase)).toBeNull();
     }
   });
-
-  it("keeps a failed codec transaction visible until sharing stops", () => {
-    expect(videoCodecLockNotice("live", true, "failed")).toBe(
-      VIDEO_CODEC_TRANSITION_FAILED_NOTICE,
-    );
-  });
 });
diff --git a/tests/host-peer-tracks.test.ts b/tests/host-peer-tracks.test.ts
index 8b19f3d..26652c4 100644
--- a/tests/host-peer-tracks.test.ts
+++ b/tests/host-peer-tracks.test.ts
@@ -11,7 +11,6 @@ import { ViewerRelay } from "../src/client/webrtc/viewer-relay.ts";
 import type {
   IceConfig,
   ParticipantRouteAssignment,
-  SignalPayload,
 } from "../src/shared/protocol.ts";
 
 const statsCallbacks: Array<() => void> = [];
@@ -393,12 +392,27 @@ describe("HostPeer source replacement", () => {
     expect(updates.at(-1)?.error).not.toContain("createOffer failed");
   });
 
-  it("leaves browser codec ordering unchanged", async () => {
+  it("prefers VP8 before the first offer by default", async () => {
     const peer = createPeer(createStream(createTrack("video", "video"), null));
 
     await expect(peer.start()).resolves.toBe(true);
 
-    expect(FakePeerConnection.latest!.codecPreferenceCalls).toEqual([]);
+    expect(
+      FakePeerConnection.latest!.codecPreferenceCalls[0]?.[0]?.mimeType,
+    ).toBe("video/VP8");
+  });
+
+  it("restores browser codec ordering for explicit automatic", async () => {
+    const peer = createPeer(
+      createStream(createTrack("video", "video"), null),
+      () => undefined,
+      { iceServers: [] },
+      { ...QUALITY_PROFILES["720p30"], videoCodec: "automatic" },
+    );
+
+    await expect(peer.start()).resolves.toBe(true);
+
+    expect(FakePeerConnection.latest!.codecPreferenceCalls).toEqual([[]]);
   });
 
   it.each(["h264", "vp8"] as const)(
@@ -436,309 +450,6 @@ describe("HostPeer source replacement", () => {
     },
   );
 
-  it("supersedes an unanswered codec offer with the next exact generation", async () => {
-    const signals: SignalPayload[] = [];
-    const peer = new HostPeer(
-      "viewer-peer",
-      { iceServers: [] },
-      createStream(createTrack("video", "video"), null),
-      QUALITY_PROFILES["720p30"],
-      {
-        sendSignal: (_peerId, payload) => {
-          signals.push(payload);
-          return true;
-        },
-        onUpdate: () => undefined,
-      },
-    );
-    await expect(peer.start()).resolves.toBe(true);
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: null,
-      description: { type: "answer", sdp: "initial-answer" },
-    });
-
-    const first = peer.prepareVideoCodec(1, "h264");
-    await vi.waitFor(() =>
-      expect(
-        signals.filter(
-          (signal) =>
-            signal.kind === "description" &&
-            signal.negotiationGeneration === 1,
-        ),
-      ).toHaveLength(1),
-    );
-    const connection = FakePeerConnection.latest!;
-    connection.signalingState = "have-local-offer";
-
-    const rollback = peer.prepareVideoCodec(2, "vp8");
-    await expect(first).resolves.toBe(false);
-    await vi.waitFor(() =>
-      expect(
-        signals.filter(
-          (signal) =>
-            signal.kind === "description" &&
-            signal.negotiationGeneration === 2,
-        ),
-      ).toHaveLength(1),
-    );
-    expect(connection.localDescription?.type).toBe("offer");
-
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: 1,
-      description: { type: "answer", sdp: "stale-answer" },
-    });
-    let rollbackSettled = false;
-    void rollback.then(() => {
-      rollbackSettled = true;
-    });
-    await Promise.resolve();
-    expect(rollbackSettled).toBe(false);
-
-    connection.signalingState = "stable";
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: 2,
-      description: { type: "answer", sdp: "rollback-answer" },
-    });
-    await expect(rollback).resolves.toBe(true);
-    expect(connection.remoteDescription?.sdp).toBe("rollback-answer");
-    expect(connection.codecPreferenceCalls).toHaveLength(2);
-  });
-
-  it("serializes an in-flight codec answer before offering a newer generation", async () => {
-    const signals: SignalPayload[] = [];
-    const peer = new HostPeer(
-      "viewer-peer",
-      { iceServers: [] },
-      createStream(createTrack("video", "video"), null),
-      QUALITY_PROFILES["720p30"],
-      {
-        sendSignal: (_peerId, payload) => {
-          signals.push(payload);
-          return true;
-        },
-        onUpdate: () => undefined,
-      },
-    );
-    await expect(peer.start()).resolves.toBe(true);
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: null,
-      description: { type: "answer", sdp: "initial-answer" },
-    });
-    signals.length = 0;
-
-    const first = peer.prepareVideoCodec(21, "h264");
-    await vi.waitFor(() =>
-      expect(
-        signals.filter(
-          (signal) =>
-            signal.kind === "description" &&
-            signal.negotiationGeneration === 21,
-        ),
-      ).toHaveLength(1),
-    );
-    const connection = FakePeerConnection.latest!;
-    connection.deferRemoteDescriptionCall = 2;
-    const staleAnswer = peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: 21,
-      description: { type: "answer", sdp: "generation-21-answer" },
-    });
-    await vi.waitFor(() =>
-      expect(connection.remoteDescriptionCallCount).toBe(2),
-    );
-
-    const second = peer.prepareVideoCodec(22, "vp8");
-    await expect(first).resolves.toBe(false);
-    await Promise.resolve();
-    expect(
-      signals.filter(
-        (signal) =>
-          signal.kind === "description" &&
-          signal.negotiationGeneration === 22,
-      ),
-    ).toEqual([]);
-
-    connection.releaseDeferredRemoteDescription();
-    await staleAnswer;
-    await vi.waitFor(() =>
-      expect(
-        signals.filter(
-          (signal) =>
-            signal.kind === "description" &&
-            signal.negotiationGeneration === 22,
-        ),
-      ).toHaveLength(1),
-    );
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: 22,
-      description: { type: "answer", sdp: "generation-22-answer" },
-    });
-    await expect(second).resolves.toBe(true);
-    expect(connection.remoteDescription?.sdp).toBe("generation-22-answer");
-  });
-
-  it("waits for the codec negotiation owner before sending an ICE restart offer", async () => {
-    const signals: SignalPayload[] = [];
-    const peer = new HostPeer(
-      "viewer-peer",
-      { iceServers: [] },
-      createStream(createTrack("video", "video"), null),
-      QUALITY_PROFILES["720p30"],
-      {
-        sendSignal: (_peerId, payload) => {
-          signals.push(payload);
-          return true;
-        },
-        onUpdate: () => undefined,
-      },
-    );
-    await expect(peer.start()).resolves.toBe(true);
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: null,
-      description: { type: "answer", sdp: "initial-answer" },
-    });
-    signals.length = 0;
-
-    const codec = peer.prepareVideoCodec(31, "h264");
-    await vi.waitFor(() =>
-      expect(
-        signals.filter(
-          (signal) =>
-            signal.kind === "description" &&
-            signal.negotiationGeneration === 31,
-        ),
-      ).toHaveLength(1),
-    );
-    const connection = FakePeerConnection.latest!;
-    const restart = peer.restartIce();
-    await new Promise<void>((resolve) => setImmediate(resolve));
-    expect(connection.restartIce).not.toHaveBeenCalled();
-    expect(
-      signals.filter(
-        (signal) =>
-          signal.kind === "description" &&
-          signal.negotiationGeneration === null,
-      ),
-    ).toEqual([]);
-
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: 31,
-      description: { type: "answer", sdp: "codec-answer" },
-    });
-    await expect(codec).resolves.toBe(true);
-    await expect(restart).resolves.toBe(true);
-    expect(connection.restartIce).toHaveBeenCalledOnce();
-    expect(
-      signals
-        .filter((signal) => signal.kind === "description")
-        .map((signal) => signal.negotiationGeneration),
-    ).toEqual([31, null]);
-  });
-
-  it("rolls back a cancelled codec offer before an ordinary ICE restart", async () => {
-    const signals: SignalPayload[] = [];
-    const peer = new HostPeer(
-      "viewer-peer",
-      { iceServers: [] },
-      createStream(createTrack("video", "video"), null),
-      QUALITY_PROFILES["720p30"],
-      {
-        sendSignal: (_peerId, payload) => {
-          signals.push(payload);
-          return true;
-        },
-        onUpdate: () => undefined,
-      },
-    );
-    await expect(peer.start()).resolves.toBe(true);
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: null,
-      description: { type: "answer", sdp: "initial-answer" },
-    });
-    signals.length = 0;
-
-    const codec = peer.prepareVideoCodec(41, "h264");
-    await vi.waitFor(() =>
-      expect(
-        signals.filter(
-          (signal) =>
-            signal.kind === "description" &&
-            signal.negotiationGeneration === 41,
-        ),
-      ).toHaveLength(1),
-    );
-    const connection = FakePeerConnection.latest!;
-    connection.signalingState = "have-local-offer";
-    peer.cancelVideoCodecPreparation();
-    const restart = peer.restartIce();
-
-    await expect(codec).resolves.toBe(false);
-    await expect(restart).resolves.toBe(true);
-    expect(connection.signalingState).toBe("stable");
-    expect(connection.restartIce).toHaveBeenCalledOnce();
-    expect(
-      signals
-        .filter((signal) => signal.kind === "description")
-        .map((signal) => signal.negotiationGeneration),
-    ).toEqual([41, null]);
-  });
-
-  it("coalesces an exact duplicate codec preparation", async () => {
-    const signals: SignalPayload[] = [];
-    const peer = new HostPeer(
-      "viewer-peer",
-      { iceServers: [] },
-      createStream(createTrack("video", "video"), null),
-      QUALITY_PROFILES["720p30"],
-      {
-        sendSignal: (_peerId, payload) => {
-          signals.push(payload);
-          return true;
-        },
-        onUpdate: () => undefined,
-      },
-    );
-    await expect(peer.start()).resolves.toBe(true);
-    const first = peer.prepareVideoCodec(4, "h264");
-    const duplicate = peer.prepareVideoCodec(4, "h264");
-
-    expect(duplicate).toBe(first);
-    await vi.waitFor(() =>
-      expect(
-        signals.filter(
-          (signal) =>
-            signal.kind === "description" &&
-            signal.negotiationGeneration === 4,
-        ),
-      ).toHaveLength(1),
-    );
-    await peer.acceptSignal({
-      kind: "description",
-      connectionId: peer.connectionId,
-      negotiationGeneration: 4,
-      description: { type: "answer", sdp: "codec-answer" },
-    });
-    await expect(first).resolves.toBe(true);
-    await expect(duplicate).resolves.toBe(true);
-  });
-
   it("applies STUN-only ICE configuration at creation and update", () => {
     const peer = createPeer(
       createStream(createTrack("video", "video"), null),
@@ -974,7 +685,6 @@ describe("HostPeer source replacement", () => {
     await peer.acceptSignal({
       kind: "description",
       connectionId: peer.connectionId,
-      negotiationGeneration: null,
       description: { type: "answer", sdp: "test-answer" },
     });
 
@@ -1436,7 +1146,6 @@ function hostProvisionalInput(
       childPeerId: childPeerIds.at(-1) ?? "candidate-child",
       connectionId: `candidate-connection-${revision}`,
       transport: "direct" as const,
-      codecTransition: null,
     },
     assignment: hostAssignment(
       childPeerIds,
@@ -1473,13 +1182,11 @@ describe("Host provisional child runtime ownership", () => {
     expect(owner.acceptSignal("wrong-child", {
       kind: "description",
       connectionId: preparedConnectionId,
-      negotiationGeneration: null,
       description: { type: "answer", sdp: "wrong-peer" },
     })).toBe(false);
     expect(owner.acceptSignal("probe-child", {
       kind: "description",
       connectionId: "wrong-connection",
-      negotiationGeneration: null,
       description: { type: "answer", sdp: "wrong-connection" },
     })).toBe(false);
     expect(owner.acceptSignal("probe-child", {
@@ -1490,7 +1197,6 @@ describe("Host provisional child runtime ownership", () => {
     expect(owner.acceptSignal("probe-child", {
       kind: "description",
       connectionId: preparedConnectionId,
-      negotiationGeneration: null,
       description: { type: "answer", sdp: "right-answer" },
     })).toBe(true);
     await vi.waitFor(() =>
@@ -1580,7 +1286,6 @@ describe("ViewerRelay downstream ownership", () => {
     childPeerId,
     connectionId: `relay-candidate-${revision}`,
     transport: "direct" as const,
-    codecTransition: null,
   });
 
   it("promotes the exact prepared child connection within the current Viewer cap", async () => {
@@ -1607,7 +1312,6 @@ describe("ViewerRelay downstream ownership", () => {
       relay.acceptSignal("prepared-child", {
         kind: "description",
         connectionId: "wrong-connection",
-        negotiationGeneration: null,
         description: { type: "answer", sdp: "wrong-answer" },
       }, 7),
     ).resolves.toBe(false);
@@ -1615,7 +1319,6 @@ describe("ViewerRelay downstream ownership", () => {
       relay.acceptSignal("prepared-child", {
         kind: "description",
         connectionId: preparedConnectionId,
-        negotiationGeneration: null,
         description: { type: "answer", sdp: "right-answer" },
       }, 6),
     ).resolves.toBe(false);
@@ -1638,7 +1341,6 @@ describe("ViewerRelay downstream ownership", () => {
       relay.acceptSignal("prepared-child", {
         kind: "description",
         connectionId: preparedConnectionId,
-        negotiationGeneration: null,
         description: { type: "answer", sdp: "right-answer" },
       }, preparedRevision),
     ).resolves.toBe(true);
diff --git a/tests/host-source-authority.test.ts b/tests/host-source-authority.test.ts
deleted file mode 100644
index 6468f50..0000000
--- a/tests/host-source-authority.test.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import { applyAuthoritativeHostPause } from "../src/client/media/host-source-authority.ts";
-
-function createStream() {
-  const videoTrack = { enabled: true } as MediaStreamTrack;
-  const audioTrack = { enabled: true } as MediaStreamTrack;
-  const stream = {
-    getTracks: () => [videoTrack, audioTrack],
-    getVideoTracks: () => [videoTrack],
-  } as unknown as MediaStream;
-  return { stream, videoTrack, audioTrack };
-}
-
-describe("Host source authority", () => {
-  it("repause disables the current share after reconnect cleared local codec state", () => {
-    const { stream, videoTrack, audioTrack } = createStream();
-    const pauseSfuRoute = vi.fn();
-    let hostPaused = false;
-
-    const result = applyAuthoritativeHostPause({
-      message: {
-        type: "pause-sharing-source",
-        shareGeneration: "share_generation_12345678",
-        codecGeneration: 7,
-        resumeAttempt: null,
-      },
-      currentShareGeneration: "share_generation_12345678",
-      activeResumeAttempt: null,
-      activeCodecGeneration: null,
-      stream,
-      pauseSfuRoute,
-      markHostPaused: () => {
-        hostPaused = true;
-      },
-    });
-
-    expect(result).toEqual({ localCodecContextMatches: false });
-    expect(videoTrack.enabled).toBe(false);
-    expect(audioTrack.enabled).toBe(false);
-    expect(pauseSfuRoute).toHaveBeenCalledOnce();
-    expect(hostPaused).toBe(true);
-  });
-
-  it("rejects a stale share before touching its source or route", () => {
-    const { stream, videoTrack, audioTrack } = createStream();
-    const pauseSfuRoute = vi.fn();
-    const markHostPaused = vi.fn();
-
-    const result = applyAuthoritativeHostPause({
-      message: {
-        type: "pause-sharing-source",
-        shareGeneration: "stale_share_generation_12345678",
-        codecGeneration: 7,
-        resumeAttempt: 3,
-      },
-      currentShareGeneration: "current_share_generation_12345678",
-      activeResumeAttempt: 3,
-      activeCodecGeneration: 7,
-      stream,
-      pauseSfuRoute,
-      markHostPaused,
-    });
-
-    expect(result).toBeNull();
-    expect(videoTrack.enabled).toBe(true);
-    expect(audioTrack.enabled).toBe(true);
-    expect(pauseSfuRoute).not.toHaveBeenCalled();
-    expect(markHostPaused).not.toHaveBeenCalled();
-  });
-});
diff --git a/tests/hybrid-media-router.test.ts b/tests/hybrid-media-router.test.ts
index f2e92ec..4a388a8 100644
--- a/tests/hybrid-media-router.test.ts
+++ b/tests/hybrid-media-router.test.ts
@@ -65,34 +65,6 @@ function complete(
   return state;
 }
 
-function deferred() {
-  let resolve!: () => void;
-  const promise = new Promise<void>((settle) => {
-    resolve = settle;
-  });
-  return { promise, resolve };
-}
-
-function reconnectHost(
-  store: RoomStore,
-  room: CreatedRoom,
-  sessionId: string,
-): AuthenticatedRouteParticipant {
-  const connected = store.connectParticipant({
-    roomId: room.roomId,
-    role: "host",
-    token: room.hostToken,
-    clientId: "host_client_12345678",
-    sessionId,
-  });
-  return {
-    roomId: room.roomId,
-    role: "host",
-    peerId: connected.peerId,
-    sessionId,
-  };
-}
-
 function preparedFor(
   sent: Map<string, ServerMessage[]>,
   sessionId: string,
@@ -679,330 +651,11 @@ describe("HybridMediaRouter v9 runtime", () => {
     await router.close();
   });
 
-  it("replaces an SFU publication through the codec-owned paused operation", async () => {
-    const { store, sent, admission, roomControl, router } = harness(
-      1,
-      true,
-      undefined,
-      1,
-    );
-    try {
-      const room = await store.createRoom();
-      const host = connectHost(store, room);
-      complete(router, host);
-      const first = connectViewer(store, room, "codec_sfu_first");
-      complete(router, first);
-      await vi.waitFor(() => expect(preparedFor(sent, first.sessionId)).toBeDefined());
-      const firstDirect = preparedFor(sent, first.sessionId)!;
-      expect(firstDirect.candidate.codecTransition).toBeNull();
-      router.handleRouteReady(first, {
-        type: "route-ready",
-        revision: firstDirect.revision,
-        phase: "prepare",
-      });
 
-      const second = connectViewer(store, room, "codec_sfu_second");
-      complete(router, second);
-      await vi.waitFor(() =>
-        expect(preparedFor(sent, first.sessionId)?.candidate.transport).toBe("sfu"),
-      );
-      const firstSfu = preparedFor(sent, first.sessionId)!;
-      router.handleRouteReady(first, {
-        type: "route-ready",
-        revision: firstSfu.revision,
-        phase: "prepare",
-      });
-      await vi.waitFor(() =>
-        expect(preparedFor(sent, second.sessionId)?.candidate.transport).toBe("sfu"),
-      );
-      const secondSfu = preparedFor(sent, second.sessionId)!;
-      router.handleRouteReady(second, {
-        type: "route-ready",
-        revision: secondSfu.revision,
-        phase: "prepare",
-      });
-      await vi.waitFor(() =>
-        expect(admission?.usage()).toEqual({ ingress: 1, egress: 2 }),
-      );
 
-      const previous = router.codecRouteSnapshot(room.roomId)!;
-      const previousPublication = (
-        previous.targets[0]!.proofBinding as Extract<
-          (typeof previous.targets)[number]["proofBinding"],
-          { kind: "sfu" }
-        >
-      ).publicationGeneration;
-      router.setPaused(room.roomId, true);
-      const preparedSnapshot = await router.beginCodecSfuReplacement({
-        roomId: room.roomId,
-        hostSessionId: host.sessionId,
-        generation: 1,
-        videoCodec: "h264",
-        timeoutMs: 1_000,
-      });
-      expect(preparedSnapshot).not.toBeNull();
-      const freshTarget = preparedSnapshot!.targets.find(
-        (target) => target.preparationBinding.kind === "sfu",
-      )!;
-      expect(freshTarget).toMatchObject({ proofReady: false });
-      expect(freshTarget.preparationBinding).not.toMatchObject({
-        publicationGeneration: previousPublication,
-      });
-      const codecPrepare = preparedFor(sent, freshTarget.viewerSessionId)!;
-      expect(codecPrepare.candidate).toMatchObject({
-        transport: "sfu",
-        codecTransition: { generation: 1, videoCodec: "h264" },
-      });
-      expect(roomControl?.deleted).toContainEqual(
-        expect.objectContaining({ publicationGeneration: previousPublication }),
-      );
-      expect(roomControl?.created).toHaveLength(2);
 
-      expect(router.parkCodecSfuReplacement(room.roomId, 1)).toBe(true);
-      const anchor =
-        freshTarget.viewerPeerId === first.peerId ? first : second;
-      router.handleRouteReady(anchor, {
-        type: "route-ready",
-        revision: codecPrepare.revision,
-        phase: "prepare",
-      });
-      expect(
-        router.codecRouteSnapshot(room.roomId)?.targets.find(
-          (target) => target.viewerPeerId === anchor.peerId,
-        )?.proofReady,
-      ).toBe(false);
 
-      expect(router.beginCodecSfuProof(room.roomId, 1, 1_000)).toBe(true);
-      router.handleRouteReady(anchor, {
-        type: "route-ready",
-        revision: codecPrepare.revision,
-        phase: "prepare",
-      });
-      await vi.waitFor(() =>
-        expect(
-          router.codecRouteSnapshot(room.roomId)?.targets.find(
-            (target) => target.viewerPeerId === anchor.peerId,
-          ),
-        ).toMatchObject({ proofReady: true }),
-      );
-      expect(admission?.usage()).toEqual({ ingress: 1, egress: 1 });
-    } finally {
-      await router.close();
-    }
-  });
 
-  it("waits for exact old-generation drain before codec creation even with spare ingress", async () => {
-    const { store, sent, admission, roomControl, router } = harness(
-      1,
-      true,
-      undefined,
-      2,
-    );
-    const drain = deferred();
-    try {
-      const room = await store.createRoom();
-      const { host } = await establishSfuRoom(store, sent, router, room);
-      await vi.waitFor(() =>
-        expect(admission?.usage()).toEqual({ ingress: 1, egress: 2 }),
-      );
-      roomControl!.deleteBarrier = drain.promise;
-      router.setPaused(room.roomId, true);
-      let settled = false;
-      const preparation = router
-        .beginCodecSfuReplacement({
-          roomId: room.roomId,
-          hostSessionId: host.sessionId,
-          generation: 1,
-          videoCodec: "h264",
-          timeoutMs: 1_000,
-        })
-        .finally(() => {
-          settled = true;
-        });
-
-      await vi.waitFor(() =>
-        expect(
-          (
-            Reflect.get(router, "resourceWaiters") as Map<string, unknown>
-          ).has(room.roomId),
-        ).toBe(true),
-      );
-      expect(roomControl?.created).toHaveLength(1);
-      expect(settled).toBe(false);
-
-      drain.resolve();
-      const snapshot = await preparation;
-      expect(snapshot).not.toBeNull();
-      expect(roomControl?.deleted).toHaveLength(1);
-      expect(roomControl?.created).toHaveLength(2);
-    } finally {
-      drain.resolve();
-      await router.close();
-    }
-  });
-
-  it("waits for an aborted fresh codec generation to drain before rollback at ingress two", async () => {
-    const { store, sent, admission, roomControl, router } = harness(
-      1,
-      true,
-      undefined,
-      2,
-    );
-    const forwardDrain = deferred();
-    try {
-      const room = await store.createRoom();
-      const { host } = await establishSfuRoom(store, sent, router, room);
-      router.setPaused(room.roomId, true);
-      const forward = await router.beginCodecSfuReplacement({
-        roomId: room.roomId,
-        hostSessionId: host.sessionId,
-        generation: 1,
-        videoCodec: "h264",
-        timeoutMs: 1_000,
-      });
-      expect(forward).not.toBeNull();
-      expect(roomControl?.created).toHaveLength(2);
-
-      roomControl!.deleteBarrier = forwardDrain.promise;
-      router.abortCodecSfuReplacement(room.roomId, 1);
-      let rollbackSettled = false;
-      const rollback = router
-        .beginCodecSfuReplacement({
-          roomId: room.roomId,
-          hostSessionId: host.sessionId,
-          generation: 2,
-          videoCodec: "automatic",
-          timeoutMs: 1_000,
-        })
-        .finally(() => {
-          rollbackSettled = true;
-        });
-
-      await vi.waitFor(() =>
-        expect(
-          (
-            Reflect.get(router, "resourceWaiters") as Map<string, unknown>
-          ).has(room.roomId),
-        ).toBe(true),
-      );
-      expect(admission?.usage()).toEqual({ ingress: 1, egress: 1 });
-      expect(roomControl?.created).toHaveLength(2);
-      expect(rollbackSettled).toBe(false);
-
-      forwardDrain.resolve();
-      await expect(rollback).resolves.not.toBeNull();
-      expect(roomControl?.created).toHaveLength(3);
-    } finally {
-      forwardDrain.resolve();
-      await router.close();
-    }
-  });
-
-  it("ignores a stale Host session failure for the current codec publication candidate", async () => {
-    const { store, sent, router } = harness(1, true);
-    try {
-      const room = await store.createRoom();
-      const { host: staleHost } = await establishSfuRoom(
-        store,
-        sent,
-        router,
-        room,
-      );
-      const currentHost = reconnectHost(
-        store,
-        room,
-        "host_session_reconnected_12345678",
-      );
-      complete(router, currentHost);
-      router.setPaused(room.roomId, true);
-      const snapshot = await router.beginCodecSfuReplacement({
-        roomId: room.roomId,
-        hostSessionId: currentHost.sessionId,
-        generation: 1,
-        videoCodec: "h264",
-        timeoutMs: 1_000,
-      });
-      expect(snapshot).not.toBeNull();
-      const target = snapshot!.targets.find(
-        (candidate) => candidate.preparationBinding.kind === "sfu",
-      )!;
-      const prepared = preparedFor(sent, target.viewerSessionId)!;
-
-      router.handleRouteFailed(staleHost, {
-        type: "route-failed",
-        revision: prepared.revision,
-        phase: "prepare",
-        connectionId: null,
-      });
-
-      expect(router.parkCodecSfuReplacement(room.roomId, 1)).toBe(true);
-      router.abortCodecSfuReplacement(room.roomId, 1);
-    } finally {
-      await router.close();
-    }
-  });
-
-  it("wakes codec revalidation when a paused active edge fails", async () => {
-    const { store, sent, onActiveRouteChanged, router } = harness(1);
-    const room = await store.createRoom();
-    const host = connectHost(store, room);
-    complete(router, host);
-    const viewer = connectViewer(store, room, "paused_hard_failure");
-    complete(router, viewer);
-    await vi.waitFor(() =>
-      expect(preparedFor(sent, viewer.sessionId)).toBeDefined(),
-    );
-    const prepared = preparedFor(sent, viewer.sessionId)!;
-    router.handleRouteReady(viewer, {
-      type: "route-ready",
-      revision: prepared.revision,
-      phase: "prepare",
-    });
-    router.setPaused(room.roomId, true);
-    onActiveRouteChanged.mockClear();
-
-    router.handleRouteFailed(viewer, {
-      type: "route-failed",
-      revision: prepared.revision,
-      phase: "active",
-      connectionId: prepared.candidate.connectionId,
-    });
-
-    expect(onActiveRouteChanged).toHaveBeenCalledTimes(1);
-    expect(onActiveRouteChanged).toHaveBeenCalledWith(room.roomId);
-    expect(router.codecRouteSnapshot(room.roomId)?.targets).toEqual([]);
-    await router.close();
-  });
-
-  it("clears an exact drain waiter on codec abort", async () => {
-    const { store, sent, roomControl, router } = harness(1, true, undefined, 2);
-    const drain = deferred();
-    try {
-      const room = await store.createRoom();
-      const { host } = await establishSfuRoom(store, sent, router, room);
-      roomControl!.deleteBarrier = drain.promise;
-      router.setPaused(room.roomId, true);
-      const preparation = router.beginCodecSfuReplacement({
-        roomId: room.roomId,
-        hostSessionId: host.sessionId,
-        generation: 1,
-        videoCodec: "h264",
-        timeoutMs: 1_000,
-      });
-      const waiters = Reflect.get(router, "resourceWaiters") as Map<
-        string,
-        unknown
-      >;
-      await vi.waitFor(() => expect(waiters.has(room.roomId)).toBe(true));
-
-      router.abortCodecSfuReplacement(room.roomId, 1);
-      await expect(preparation).resolves.toBeNull();
-      expect(waiters.has(room.roomId)).toBe(false);
-    } finally {
-      drain.resolve();
-      await router.close();
-    }
-  });
 
   it("emits typed exhaustion and clears diagnostics on departure and room deletion", async () => {
     const { store, sent, router } = harness(1);
diff --git a/tests/media-assignment.test.ts b/tests/media-assignment.test.ts
index ec8b149..139bf63 100644
--- a/tests/media-assignment.test.ts
+++ b/tests/media-assignment.test.ts
@@ -13,7 +13,6 @@ import {
 const offer: SignalPayload = {
   kind: "description",
   connectionId: "connection_12345678",
-  negotiationGeneration: null,
   description: { type: "offer", sdp: "test-offer" },
 };
 
diff --git a/tests/protocol.test.ts b/tests/protocol.test.ts
index 1b6a44b..0d35c64 100644
--- a/tests/protocol.test.ts
+++ b/tests/protocol.test.ts
@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 
 import {
+  DEFAULT_QUALITY_SETTINGS,
   DEFAULT_VIEWER_DISPLAY_NAME,
   MAX_DISPLAY_NAME_CODE_POINTS,
   MAX_MEDIA_ROUTE_REVISION,
@@ -66,7 +67,7 @@ const qualityEvidence = {
 } as const;
 
 describe("client signaling protocol", () => {
-  it("keeps executable senders outside the Browser-only v9 checkpoint", () => {
+  it("keeps executable senders outside the Browser-only v10 checkpoint", () => {
     const nativeWire = readFileSync(
       join(
         import.meta.dirname,
@@ -75,7 +76,7 @@ describe("client signaling protocol", () => {
       "utf8",
     );
 
-    expect(SIGNALING_PROTOCOL).toBe("screener-v9");
+    expect(SIGNALING_PROTOCOL).toBe("screener-v10");
     expect(nativeWire).toMatch(/signalingProtocol\s*=\s*"screener-v6"/);
   });
 
@@ -236,6 +237,24 @@ describe("client signaling protocol", () => {
         }),
       ),
     ).toMatchObject({ viewerGrant });
+    expect(
+      decodeClientMessage(
+        JSON.stringify({
+          type: "authenticate",
+          protocol: SIGNALING_PROTOCOL,
+          roomId,
+          role: "host",
+          token,
+          clientId: "host_client_12345678",
+          shareGeneration: "share_generation_12345678",
+          qualitySettings: qualitySettingsWithCodec,
+        }),
+      ),
+    ).toMatchObject({
+      role: "host",
+      shareGeneration: "share_generation_12345678",
+      qualitySettings: qualitySettingsWithCodec,
+    });
     expect(
       clientMessageSchema.safeParse({
         type: "authenticate",
@@ -254,17 +273,15 @@ describe("client signaling protocol", () => {
         clientId: "client_12345678",
       }).success,
     ).toBe(false);
-    for (const protocol of ["screener-v8", "screener-v3"]) {
-      expect(
-        clientMessageSchema.safeParse({
-          type: "authenticate",
-          protocol,
-          roomId,
-          role: "viewer",
-          clientId: "client_12345678",
-        }).success,
-      ).toBe(false);
-    }
+    expect(
+      clientMessageSchema.safeParse({
+        type: "authenticate",
+        protocol: "invalid-protocol",
+        roomId,
+        role: "viewer",
+        clientId: "client_12345678",
+      }).success,
+    ).toBe(false);
   });
 
   it("normalizes display names and rejects misleading Unicode boundaries", () => {
@@ -411,18 +428,6 @@ describe("client signaling protocol", () => {
     expect(result.success).toBe(false);
   });
 
-  it("rejects the previous signaling wire", () => {
-    expect(
-      clientMessageSchema.safeParse({
-        type: "authenticate",
-        protocol: "screener-v5",
-        roomId,
-        role: "viewer",
-        clientId: "client_12345678",
-      }).success,
-    ).toBe(false);
-  });
-
   it("requires a host token and rejects viewer tokens or malformed room codes", () => {
     expect(
       clientMessageSchema.safeParse({
@@ -539,18 +544,24 @@ describe("client signaling protocol", () => {
   });
 
   it("keeps intentional pause updates strict and generation-bound", () => {
-    const update = {
+    const pause = {
       type: "set-sharing-paused",
       shareGeneration: "share_generation_12345678",
       paused: true,
     };
-    expect(clientMessageSchema.safeParse(update).success).toBe(true);
+    expect(clientMessageSchema.safeParse(pause).success).toBe(true);
     expect(
-      clientMessageSchema.safeParse({ ...update, shareGeneration: undefined })
+      clientMessageSchema.safeParse({ ...pause, paused: false }).success,
+    ).toBe(true);
+    expect(
+      clientMessageSchema.safeParse({ ...pause, shareGeneration: undefined })
         .success,
     ).toBe(false);
     expect(
-      clientMessageSchema.safeParse({ ...update, paused: "true" }).success,
+      clientMessageSchema.safeParse({ ...pause, paused: "true" }).success,
+    ).toBe(false);
+    expect(
+      clientMessageSchema.safeParse({ ...pause, unexpected: 1 }).success,
     ).toBe(false);
     expect(
       serverMessageSchema.safeParse({
@@ -563,79 +574,21 @@ describe("client signaling protocol", () => {
       serverMessageSchema.safeParse({ type: "host-status", online: true })
         .success,
     ).toBe(false);
-  });
-
-  it("requires one exact Resume attempt across authorization, ack, and proof", () => {
-    const sourceAck = {
-      type: "sharing-source-enabled",
+    const authoritativePause = {
+      type: "pause-sharing-source",
       shareGeneration: "share_generation_12345678",
-      codecGeneration: 4,
-      resumeAttempt: 9,
     };
-    expect(clientMessageSchema.safeParse(sourceAck).success).toBe(true);
-    expect(
-      clientMessageSchema.safeParse({ ...sourceAck, resumeAttempt: undefined })
-        .success,
-    ).toBe(false);
-
-    const proof = {
-      type: "video-codec-proof",
-      shareGeneration: "share_generation_12345678",
-      generation: 4,
-      resumeAttempt: 9,
-      routeRevision: 7,
-      binding: { kind: "peer", connectionId: "connection_12345678" },
-      evidence: {
-        baselineSampleTimestampMs: 100,
-        sampleTimestampMs: 200,
-        rtpStatsId: "inbound_video_12345678",
-        rtpSsrc: 42,
-        rtpMid: "0",
-        rtpRid: null,
-        trackIdentifier: "track_12345678",
-        framesDecodedDelta: 1,
-        actualCodec: "h264",
-      },
-    };
-    expect(clientMessageSchema.safeParse(proof).success).toBe(true);
-    expect(
-      clientMessageSchema.safeParse({ ...proof, resumeAttempt: undefined })
-        .success,
-    ).toBe(false);
-
-    const authorization = {
-      type: "sharing-resume-authorized",
-      shareGeneration: "share_generation_12345678",
-      codecGeneration: 4,
-      resumeAttempt: 9,
-    };
-    expect(serverMessageSchema.safeParse(authorization).success).toBe(true);
+    expect(serverMessageSchema.safeParse(authoritativePause).success).toBe(true);
     expect(
       serverMessageSchema.safeParse({
-        ...authorization,
-        resumeAttempt: undefined,
-      }).success,
-    ).toBe(false);
-
-    const proofRequest = {
-      type: "video-codec-proof-request",
-      shareGeneration: "share_generation_12345678",
-      generation: 4,
-      resumeAttempt: 9,
-      routeRevision: 7,
-      expectedCodec: "h264",
-      binding: { kind: "peer", connectionId: "connection_12345678" },
-    };
-    expect(serverMessageSchema.safeParse(proofRequest).success).toBe(true);
-    expect(
-      serverMessageSchema.safeParse({
-        ...proofRequest,
-        resumeAttempt: undefined,
+        ...authoritativePause,
+        unexpected: null,
       }).success,
     ).toBe(false);
   });
 
   it("accepts only strict, bounded quality settings", () => {
+    expect(DEFAULT_QUALITY_SETTINGS.videoCodec).toBe("vp8");
     expect(
       clientMessageSchema.safeParse({
         type: "set-quality-settings",
@@ -1314,7 +1267,6 @@ describe("server signaling protocol", () => {
           childPeerId: "child_12345678",
           connectionId: "connection_12345678",
           transport: "direct",
-          codecTransition: null,
         },
       }).success,
     ).toBe(true);
@@ -1328,7 +1280,6 @@ describe("server signaling protocol", () => {
           childPeerId: "child_12345678",
           connectionId: "connection_12345678",
           transport: "sfu",
-          codecTransition: { generation: 4, videoCodec: "h264" },
         },
       }).success,
     ).toBe(true);
@@ -1342,6 +1293,7 @@ describe("server signaling protocol", () => {
           childPeerId: "child_12345678",
           connectionId: "connection_12345678",
           transport: "direct",
+          unexpected: null,
         },
       }).success,
     ).toBe(false);
diff --git a/tests/quality.test.ts b/tests/quality.test.ts
index 61cb5ad..011cfb8 100644
--- a/tests/quality.test.ts
+++ b/tests/quality.test.ts
@@ -51,7 +51,13 @@ describe("realtime quality controls", () => {
       resolution: "1080p",
       maxFramerate: 30,
       maxBitrate: 5_000_000,
+      videoCodec: "vp8",
     });
+    expect(
+      Object.values(QUALITY_PROFILES).every(
+        (profile) => profile.videoCodec === "vp8",
+      ),
+    ).toBe(true);
   });
 
   it("offers 854x480 only through advanced resolution settings", () => {
diff --git a/tests/room-route-controller.test.ts b/tests/room-route-controller.test.ts
index 55b4c06..66b61d5 100644
--- a/tests/room-route-controller.test.ts
+++ b/tests/room-route-controller.test.ts
@@ -6,7 +6,6 @@ import {
   type CandidateCursorGuard,
   type CandidateReservation,
   type CommittedEdgeSeed,
-  type EdgeGuard,
   type OperationSnapshot,
 } from "../src/server/room-route-controller.ts";
 
@@ -53,7 +52,6 @@ function addViewer(
 
 function cursorGuard(operation: OperationSnapshot): CandidateCursorGuard {
   return {
-    owner: { ...operation.owner },
     childPeerId: operation.childPeerId,
     childSessionId: operation.childSessionId,
     baseRevision: operation.baseRevision,
@@ -126,26 +124,6 @@ function peerEdge(
   };
 }
 
-function beginCodecSfu(
-  routes: RoomRouteController<string>,
-  overrides: Partial<
-    Parameters<typeof routes.beginCodecSfuPublication>[0]
-  > = {},
-) {
-  return routes.beginCodecSfuPublication({
-    routeRevision: routes.snapshot().revision,
-    hostSessionId: "host_session",
-    codecGeneration: 1,
-    videoCodec: "h264",
-    publicationGeneration: "publication_fresh",
-    connectionId: "subscription_fresh",
-    publicationConnectionId: "publication_connection_fresh",
-    nowMs: 10,
-    deadlineAtMs: 110,
-    ...overrides,
-  });
-}
-
 describe("RoomRouteController", () => {
   it("retains one latest timing sample for a 20-Viewer burst", () => {
     const routes = controller(2);
@@ -1139,621 +1117,6 @@ describe("RoomRouteController", () => {
     });
   });
 
-  it("starts one codec-owned SFU gap with a deterministic anchor and retained subtrees", () => {
-    const routes = controller(1, { sfuEnabled: true });
-    addViewer(routes, B, 1);
-    addViewer(routes, A, 0);
-    addViewer(routes, C, 0);
-    routes.hydrateHostPublication(
-      "publication_old",
-      "publication_resource_old",
-      "publication_connection_old",
-    );
-    for (const peerId of [B, A]) {
-      routes.hydrateEdge(peerId, {
-        kind: "sfu",
-        publicationGeneration: "publication_old",
-        transport: "sfu",
-        connectionId: `${peerId}_sfu_old`,
-        usable: true,
-        physicalActive: true,
-        resource: `${peerId}_subscription_old`,
-      });
-    }
-    routes.hydrateEdge(C, peerEdge(B, "c_from_b"));
-    routes.setPaused(true);
-
-    const begun = beginCodecSfu(routes);
-    expect(begun).toMatchObject({
-      accepted: true,
-      activeRevision: 1,
-      anchorPeerId: B,
-      retiredPeerIds: [B, A],
-      operation: {
-        owner: {
-          kind: "codec",
-          codecGeneration: 1,
-          phase: "preparing",
-          videoCodec: "h264",
-          publicationGeneration: "publication_fresh",
-          connectionId: "subscription_fresh",
-          publicationConnectionId: "publication_connection_fresh",
-        },
-        childPeerId: B,
-        candidates: [{ tuple: { kind: "sfu", publication: "replace" } }],
-      },
-    });
-    expect(begun.released).toEqual(expect.arrayContaining([
-      "publication_resource_old",
-      `${B}_subscription_old`,
-      `${A}_subscription_old`,
-    ]));
-    expect(begun.released).toHaveLength(3);
-    expect(routes.snapshot().hostPublication).toMatchObject({
-      generation: "publication_old",
-      usable: false,
-      physicalActive: false,
-    });
-    for (const peerId of [B, A]) {
-      expect(routes.snapshot().upstreamByViewer.get(peerId)).toMatchObject({
-        kind: "sfu",
-        publicationGeneration: "publication_old",
-        usable: false,
-        physicalActive: false,
-      });
-    }
-    expect(routes.snapshot().upstreamByViewer.get(C)).toMatchObject({
-      kind: "peer",
-      parentPeerId: B,
-      usable: true,
-      physicalActive: true,
-    });
-    expect(beginCodecSfu(routes, { codecGeneration: 2 }).accepted).toBe(false);
-  });
-
-  it("parks an exact codec SFU attempt until proving and rebinds logical subscribers on commit", () => {
-    const routes = controller(1, { sfuEnabled: true });
-    addViewer(routes, A, 0);
-    addViewer(routes, B, 0);
-    routes.hydrateHostPublication(
-      "publication_old",
-      "publication_resource_old",
-      "publication_connection_old",
-    );
-    for (const peerId of [A, B]) {
-      routes.hydrateEdge(peerId, {
-        kind: "sfu",
-        publicationGeneration: "publication_old",
-        transport: "sfu",
-        connectionId: `${peerId}_sfu_old`,
-        usable: true,
-        physicalActive: true,
-        resource: `${peerId}_subscription_old`,
-      });
-    }
-    routes.setPaused(true);
-    const begun = beginCodecSfu(routes);
-    const guard = begun.guard!;
-
-    const wrongIdentity = beginCandidate(routes, {
-      nowMs: 11,
-      connectionId: "wrong_subscription",
-      publicationGeneration: "publication_fresh",
-      publicationConnectionId: "publication_connection_fresh",
-      reservation: {
-        kind: "sfu-create",
-        edge: "wrong_edge_reservation",
-        publication: "wrong_publication_reservation",
-      },
-    });
-    expect(wrongIdentity.accepted).toBe(false);
-    expect(wrongIdentity.released).toEqual([
-      "wrong_edge_reservation",
-      "wrong_publication_reservation",
-    ]);
-
-    const pending = beginCandidate(routes, {
-      nowMs: 12,
-      connectionId: guard.connectionId,
-      publicationGeneration: guard.publicationGeneration,
-      publicationConnectionId: guard.publicationConnectionId,
-      reservation: {
-        kind: "sfu-create",
-        edge: "subscription_resource_fresh",
-        publication: "publication_resource_fresh",
-      },
-    }).operation!;
-    const readyGuard: CandidateGuard = {
-      childPeerId: pending.childPeerId,
-      childSessionId: pending.childSessionId,
-      revision: pending.current!.revision,
-      connectionId: guard.connectionId,
-    };
-    expect(routes.candidateReady(readyGuard, 13).accepted).toBe(false);
-    expect(routes.transitionCodecOperation({
-      guard,
-      expectedPhase: "preparing",
-      phase: "prepared",
-    }).accepted).toBe(true);
-    expect(routes.operationExpired(10_000).accepted).toBe(false);
-    expect(routes.snapshot().operation?.owner).toMatchObject({
-      kind: "codec",
-      phase: "prepared",
-    });
-    expect(routes.candidateReady(readyGuard, 10_001).accepted).toBe(false);
-    expect(routes.transitionCodecOperation({
-      guard: { ...guard, connectionId: "stale_connection" },
-      expectedPhase: "prepared",
-      phase: "proving",
-      nowMs: 20,
-      deadlineAtMs: 30,
-    }).accepted).toBe(false);
-    expect(routes.transitionCodecOperation({
-      guard,
-      expectedPhase: "prepared",
-      phase: "proving",
-      nowMs: 20,
-      deadlineAtMs: 30,
-    }).accepted).toBe(true);
-    expect(routes.transitionCodecOperation({
-      guard,
-      expectedPhase: "proving",
-      phase: "prepared",
-    }).accepted).toBe(true);
-    expect(routes.operationExpired(1_000).accepted).toBe(false);
-    expect(routes.candidateReady(readyGuard, 1_001).accepted).toBe(false);
-    expect(routes.transitionCodecOperation({
-      guard,
-      expectedPhase: "prepared",
-      phase: "proving",
-      nowMs: 22,
-      deadlineAtMs: 40,
-    }).accepted).toBe(true);
-
-    expect(routes.candidateReady(readyGuard, 23).accepted).toBe(true);
-    const committed = routes.snapshot();
-    expect(committed.operation).toBeUndefined();
-    expect(committed.hostPublication).toMatchObject({
-      generation: "publication_fresh",
-      connectionId: "publication_connection_fresh",
-      usable: true,
-      physicalActive: true,
-      resource: "publication_resource_fresh",
-    });
-    expect(committed.upstreamByViewer.get(A)).toMatchObject({
-      publicationGeneration: "publication_fresh",
-      connectionId: "subscription_fresh",
-      usable: true,
-      physicalActive: true,
-      resource: "subscription_resource_fresh",
-    });
-    expect(committed.upstreamByViewer.get(B)).toMatchObject({
-      publicationGeneration: "publication_fresh",
-      usable: false,
-      physicalActive: false,
-      resource: `${B}_subscription_old`,
-    });
-  });
-
-  it("folds an invalid direct binding into the pending codec revision", () => {
-    const routes = controller(1, { sfuEnabled: true });
-    addViewer(routes, A, 1);
-    addViewer(routes, B, 0);
-    routes.hydrateHostPublication(
-      "publication_old",
-      "publication_resource_old",
-      "publication_connection_old",
-    );
-    routes.hydrateEdge(A, {
-      kind: "sfu",
-      publicationGeneration: "publication_old",
-      transport: "sfu",
-      connectionId: "a_sfu_old",
-      usable: true,
-      physicalActive: true,
-      resource: "a_subscription_old",
-    });
-    routes.hydrateEdge(B, peerEdge(A, "b_from_a"));
-    routes.setPaused(true);
-    const begun = beginCodecSfu(routes);
-    const guard = begun.guard!;
-    const pending = beginCandidate(routes, {
-      nowMs: 11,
-      connectionId: guard.connectionId,
-      publicationGeneration: guard.publicationGeneration,
-      publicationConnectionId: guard.publicationConnectionId,
-      reservation: {
-        kind: "sfu-create",
-        edge: "subscription_resource_fresh",
-        publication: "publication_resource_fresh",
-      },
-    }).operation!;
-    const pendingRevision = pending.current!.revision;
-    const activeRevision = routes.snapshot().revision;
-
-    expect(
-      routes.retireCommittedTransportsForRouteWait(
-        [
-          {
-            childPeerId: B,
-            childSessionId: `${B}_session`,
-            parentSessionId: `${A}_session`,
-            routeRevision: activeRevision,
-            connectionId: "b_from_a",
-          },
-        ],
-        12,
-      ),
-    ).toMatchObject({
-      accepted: true,
-      activeRevision,
-      retiredPeerIds: [B],
-    });
-    expect(routes.snapshot().revision).toBe(activeRevision);
-    expect(routes.snapshot().upstreamByViewer.get(B)).toMatchObject({
-      usable: false,
-      physicalActive: true,
-    });
-    expect(routes.snapshot().operation?.current?.revision).toBe(pendingRevision);
-
-    expect(
-      routes.transitionCodecOperation({
-        guard,
-        expectedPhase: "preparing",
-        phase: "prepared",
-      }).accepted,
-    ).toBe(true);
-    expect(
-      routes.transitionCodecOperation({
-        guard,
-        expectedPhase: "prepared",
-        phase: "proving",
-        nowMs: 13,
-        deadlineAtMs: 30,
-      }).accepted,
-    ).toBe(true);
-    expect(
-      routes.candidateReady(
-        {
-          childPeerId: A,
-          childSessionId: `${A}_session`,
-          revision: pendingRevision,
-          connectionId: guard.connectionId,
-        },
-        14,
-      ).accepted,
-    ).toBe(true);
-    expect(routes.snapshot().revision).toBe(pendingRevision);
-    expect(routes.snapshot().upstreamByViewer.get(B)).toMatchObject({
-      usable: false,
-      physicalActive: false,
-    });
-  });
-
-  it.each([
-    ["before-candidate", "commit"],
-    ["before-candidate", "abort"],
-    ["after-candidate", "commit"],
-    ["after-candidate", "abort"],
-  ] as const)(
-    "retires a C=2 invalid exact edge folded %s through codec %s",
-    (foldAt, outcome) => {
-      const routes = controller(2, { sfuEnabled: true });
-      addViewer(routes, A, 0);
-      addViewer(routes, B, 0);
-      routes.hydrateHostPublication(
-        "publication_old",
-        "publication_resource_old",
-        "publication_connection_old",
-      );
-      routes.hydrateEdge(A, {
-        kind: "sfu",
-        publicationGeneration: "publication_old",
-        transport: "sfu",
-        connectionId: "a_sfu_old",
-        usable: true,
-        physicalActive: true,
-        resource: "a_subscription_old",
-      });
-      routes.hydrateEdge(B, peerEdge(HOST, "b_from_host"));
-      routes.setPaused(true);
-      const begun = beginCodecSfu(routes);
-      const guard = begun.guard!;
-      const activeRevision = routes.snapshot().revision;
-      const directGuard: EdgeGuard = {
-        childPeerId: B,
-        childSessionId: `${B}_session`,
-        parentSessionId: "host_session",
-        routeRevision: activeRevision,
-        connectionId: "b_from_host",
-      };
-      const invalidateAndFold = (nowMs: number) => {
-        expect(routes.invalidateEdge(directGuard, nowMs)).toBe(true);
-        expect(routes.snapshot().upstreamByViewer.get(B)).toMatchObject({
-          usable: false,
-          physicalActive: true,
-        });
-        const invalidatedFactVersion = routes.snapshot().factVersion;
-        expect(
-          routes.retireCommittedTransportsForRouteWait(
-            [directGuard],
-            nowMs + 1,
-          ),
-        ).toMatchObject({
-          accepted: true,
-          activeRevision,
-          released: [],
-        });
-        expect(routes.snapshot().factVersion).toBe(invalidatedFactVersion);
-        expect(routes.invalidateEdge(directGuard, nowMs + 2)).toBe(true);
-        expect(
-          routes.retireCommittedTransportsForRouteWait(
-            [directGuard],
-            nowMs + 3,
-          ),
-        ).toMatchObject({
-          accepted: true,
-          activeRevision,
-          released: [],
-        });
-        expect(routes.snapshot().factVersion).toBe(invalidatedFactVersion);
-        expect(routes.snapshot().upstreamByViewer.get(B)).toMatchObject({
-          usable: false,
-          physicalActive: true,
-        });
-      };
-
-      if (foldAt === "before-candidate") invalidateAndFold(11);
-      const pending = beginCandidate(routes, {
-        nowMs: 20,
-        connectionId: guard.connectionId,
-        publicationGeneration: guard.publicationGeneration,
-        publicationConnectionId: guard.publicationConnectionId,
-        reservation: {
-          kind: "sfu-create",
-          edge: "subscription_resource_fresh",
-          publication: "publication_resource_fresh",
-        },
-      }).operation!;
-      if (foldAt === "after-candidate") invalidateAndFold(21);
-      expect(
-        routes.transitionCodecOperation({
-          guard,
-          expectedPhase: "preparing",
-          phase: "prepared",
-        }).accepted,
-      ).toBe(true);
-      expect(routes.operationExpired(1_000_000).accepted).toBe(false);
-
-      if (outcome === "commit") {
-        expect(
-          routes.transitionCodecOperation({
-            guard,
-            expectedPhase: "prepared",
-            phase: "proving",
-            nowMs: 30,
-            deadlineAtMs: 40,
-          }).accepted,
-        ).toBe(true);
-        const settled = routes.candidateReady(
-          {
-            childPeerId: A,
-            childSessionId: `${A}_session`,
-            revision: pending.current!.revision,
-            connectionId: guard.connectionId,
-          },
-          31,
-        );
-        expect(settled.accepted).toBe(true);
-        expect(settled.activeRevision).toBe(pending.current!.revision);
-      } else {
-        const aborted = routes.abortCodecOperation(guard, 31);
-        expect(aborted.accepted).toBe(true);
-        expect(aborted.activeRevision).toBeGreaterThan(
-          pending.current!.revision,
-        );
-        expect(aborted.released).toEqual([
-          "subscription_resource_fresh",
-          "publication_resource_fresh",
-        ]);
-      }
-      expect(routes.snapshot().upstreamByViewer.get(B)).toMatchObject({
-        usable: false,
-        physicalActive: false,
-      });
-      expect(
-        routes.retireCommittedTransportsForRouteWait([directGuard], 32),
-      ).toMatchObject({ accepted: false, released: [] });
-    },
-  );
-
-  it("aborts an exact pending codec publication and starts a fresh retained-anchor rollback", () => {
-    const routes = controller(1, { sfuEnabled: true });
-    addViewer(routes, A, 0);
-    routes.hydrateHostPublication(
-      "publication_old",
-      "publication_resource_old",
-      "publication_connection_old",
-    );
-    routes.hydrateEdge(A, {
-      kind: "sfu",
-      publicationGeneration: "publication_old",
-      transport: "sfu",
-      connectionId: "subscription_old",
-      usable: true,
-      physicalActive: true,
-      resource: "subscription_resource_old",
-    });
-    routes.setPaused(true);
-    const forward = beginCodecSfu(routes);
-    const forwardGuard = forward.guard!;
-    const pending = beginCandidate(routes, {
-      nowMs: 11,
-      connectionId: forwardGuard.connectionId,
-      publicationGeneration: forwardGuard.publicationGeneration,
-      publicationConnectionId: forwardGuard.publicationConnectionId,
-      reservation: {
-        kind: "sfu-create",
-        edge: "forward_subscription_resource",
-        publication: "forward_publication_resource",
-      },
-    }).operation!;
-    const pendingRevision = pending.current!.revision;
-
-    expect(routes.abortCodecOperation({
-      ...forwardGuard,
-      codecGeneration: 2,
-    }, 12).accepted).toBe(false);
-    const aborted = routes.abortCodecOperation(forwardGuard, 12);
-    expect(aborted.accepted).toBe(true);
-    expect(aborted.activeRevision).toBeGreaterThan(pendingRevision);
-    expect(aborted.released).toEqual([
-      "forward_subscription_resource",
-      "forward_publication_resource",
-    ]);
-    expect(routes.snapshot().operation).toBeUndefined();
-    expect(routes.snapshot().upstreamByViewer.get(A)).toMatchObject({
-      publicationGeneration: "publication_old",
-      usable: false,
-      physicalActive: false,
-    });
-
-    const rollback = beginCodecSfu(routes, {
-      routeRevision: routes.snapshot().revision,
-      codecGeneration: 2,
-      videoCodec: "automatic",
-      publicationGeneration: "publication_rollback",
-      connectionId: "subscription_rollback",
-      publicationConnectionId: "publication_connection_rollback",
-      nowMs: 20,
-      deadlineAtMs: 120,
-      retainedAnchor: {
-        childPeerId: A,
-        childSessionId: `${A}_session`,
-      },
-    });
-    expect(rollback).toMatchObject({
-      accepted: true,
-      anchorPeerId: A,
-      retiredPeerIds: [],
-      released: [],
-      operation: {
-        owner: {
-          kind: "codec",
-          codecGeneration: 2,
-          phase: "preparing",
-          videoCodec: "automatic",
-          publicationGeneration: "publication_rollback",
-        },
-        candidates: [{ tuple: { kind: "sfu", publication: "replace" } }],
-      },
-    });
-  });
-
-  it.each(["preparing", "proving"] as const)(
-    "reselects a connected logical SFU placeholder when the %s anchor leaves",
-    (phase) => {
-      const routes = controller(1, { sfuEnabled: true });
-      addViewer(routes, A, 0);
-      addViewer(routes, B, 0);
-      routes.hydrateHostPublication(
-        "publication_old",
-        "publication_resource_old",
-        "publication_connection_old",
-      );
-      for (const peerId of [A, B]) {
-        routes.hydrateEdge(peerId, {
-          kind: "sfu",
-          publicationGeneration: "publication_old",
-          transport: "sfu",
-          connectionId: `${peerId}_sfu_old`,
-          usable: true,
-          physicalActive: true,
-          resource: `${peerId}_subscription_old`,
-        });
-      }
-      routes.setPaused(true);
-      const forward = beginCodecSfu(routes);
-      const guard = forward.guard!;
-      beginCandidate(routes, {
-        nowMs: 11,
-        connectionId: guard.connectionId,
-        publicationGeneration: guard.publicationGeneration,
-        publicationConnectionId: guard.publicationConnectionId,
-        reservation: {
-          kind: "sfu-create",
-          edge: "forward_subscription_resource",
-          publication: "forward_publication_resource",
-        },
-      });
-      if (phase === "proving") {
-        expect(routes.transitionCodecOperation({
-          guard,
-          expectedPhase: "preparing",
-          phase: "prepared",
-        }).accepted).toBe(true);
-        expect(routes.transitionCodecOperation({
-          guard,
-          expectedPhase: "prepared",
-          phase: "proving",
-          nowMs: 12,
-          deadlineAtMs: 112,
-        }).accepted).toBe(true);
-      }
-
-      expect(routes.disconnectSession(A, `${A}_session`)).toBe(true);
-      expect(routes.confirmDeparture(A, 13)).toBe(true);
-      expect(routes.abortCodecOperation(guard, 14).accepted).toBe(true);
-      const rollback = beginCodecSfu(routes, {
-        routeRevision: routes.snapshot().revision,
-        codecGeneration: 2,
-        videoCodec: "automatic",
-        publicationGeneration: `publication_rollback_${phase}`,
-        connectionId: `subscription_rollback_${phase}`,
-        publicationConnectionId: `publication_connection_rollback_${phase}`,
-        nowMs: 20,
-        deadlineAtMs: 120,
-      });
-      expect(rollback).toMatchObject({
-        accepted: true,
-        anchorPeerId: B,
-        operation: {
-          owner: {
-            kind: "codec",
-            codecGeneration: 2,
-            phase: "preparing",
-          },
-          childPeerId: B,
-          candidates: [
-            { tuple: { kind: "sfu", publication: "replace" } },
-          ],
-        },
-      });
-    },
-  );
-
-  it("creates a codec SFU publication for an exact retained waiting anchor", () => {
-    const routes = controller(1, { sfuEnabled: true });
-    addViewer(routes, A, 0);
-    routes.setPaused(true);
-    const begun = beginCodecSfu(routes, {
-      retainedAnchor: {
-        childPeerId: A,
-        childSessionId: `${A}_session`,
-      },
-    });
-    expect(begun).toMatchObject({
-      accepted: true,
-      anchorPeerId: A,
-      activeRevision: 0,
-      retiredPeerIds: [],
-      released: [],
-      operation: {
-        owner: { kind: "codec", phase: "preparing" },
-        candidates: [{ tuple: { kind: "sfu", publication: "create" } }],
-      },
-    });
-  });
 
   it("replaces one publication and makes every old subscriber waiting", () => {
     const routes = controller(1, { sfuEnabled: true });
diff --git a/tests/route-transition.test.ts b/tests/route-transition.test.ts
index 50e0592..f94f8e8 100644
--- a/tests/route-transition.test.ts
+++ b/tests/route-transition.test.ts
@@ -82,12 +82,10 @@ const candidate = (
   childPeerId = "viewer_12345678",
   transport: "direct" | "sfu" = "direct",
   connectionId = `candidate_${revision}_12345678`,
-  codecTransition: PreparedRouteCandidate["codecTransition"] = null,
 ): PreparedRouteCandidate => ({
   childPeerId,
   connectionId,
   transport,
-  codecTransition,
 });
 
 function createFakeSubscriber(events: SubscriberEvents, log: string[], label: string) {
@@ -144,37 +142,6 @@ describe("minimal route transition contracts", () => {
     ).toBe("stale");
   });
 
-  it("treats the codec transaction tag as part of exact candidate identity", () => {
-    const route = new MediaRouteTransition();
-    const assignment = viewerSfuAssignment();
-    const tagged = candidate(
-      2,
-      "viewer_12345678",
-      "sfu",
-      "candidate_2_12345678",
-      { generation: 7, videoCodec: "h264" },
-    );
-
-    expect(
-      route.accept({
-        revision: 2,
-        phase: "prepare",
-        assignment,
-        candidate: tagged,
-      }),
-    ).toBe("accepted");
-    expect(
-      route.accept({
-        revision: 2,
-        phase: "prepare",
-        assignment,
-        candidate: {
-          ...tagged,
-          codecTransition: { generation: 8, videoCodec: "h264" },
-        },
-      }),
-    ).toBe("stale");
-  });
 
   it("keeps duplicate peer prepare idempotent and releases it before takeover", async () => {
     const prepared: Array<{ parentPeerId: string | null; revision?: number }> = [];
@@ -336,143 +303,21 @@ describe("minimal route transition contracts", () => {
     expect(publishers[1]?.disconnect).not.toHaveBeenCalled();
   });
 
-  it("prepares a fresh tagged SFU publisher while paused with the tagged codec", async () => {
-    const messages: ClientMessage[] = [];
-    const prepared: unknown[] = [];
-    const publishers: ReturnType<typeof createFakePublisher>[] = [];
-    const route = new HostSfuRoute({
-      getStream: () => ({}) as MediaStream,
-      getProfile: () => QUALITY_PROFILES["720p30"],
-      reconcileChildren: () => undefined,
-      send: (message) => {
-        messages.push(message);
-        return true;
-      },
-      onCodecPublisherPrepared: (result) => prepared.push(result),
-      createPublisher: () => {
-        const publisher = createFakePublisher([], "codec-publisher");
-        publishers.push(publisher);
-        return publisher;
-      },
-    });
 
-    route.setPaused(true);
-    route.accept({
-      revision: 2,
-      phase: "prepare",
-      assignment: hostAssignment("ordinary-publication"),
-      candidate: candidate(2, "viewer_12345678", "sfu"),
-    });
-    await route.acceptConfig(sfuConfig(2));
-    expect(publishers).toEqual([]);
-
-    route.accept({
-      revision: 3,
-      phase: "prepare",
-      assignment: hostAssignment("fresh-publication"),
-      candidate: candidate(
-        3,
-        "viewer_12345678",
-        "sfu",
-        "candidate_3_12345678",
-        { generation: 11, videoCodec: "h264" },
-      ),
-    });
-    await route.acceptConfig(sfuConfig(3));
-
-    expect(publishers).toHaveLength(1);
-    expect(publishers[0]?.activate).toHaveBeenCalledWith(
-      expect.anything(),
-      { ...QUALITY_PROFILES["720p30"], videoCodec: "h264" },
-    );
-    expect(prepared).toEqual([
-      {
-        generation: 11,
-        videoCodec: "h264",
-        binding: {
-          kind: "sfu",
-          publicationGeneration: "fresh-publication",
-        },
-        accepted: true,
-      },
-    ]);
-    expect(messages.filter((message) => message.type === "route-ready")).toEqual([]);
-  });
-
-  it("reports an exact rejected binding when fresh codec publication fails", async () => {
-    const prepared: unknown[] = [];
-    const route = new HostSfuRoute({
-      getStream: () => ({}) as MediaStream,
-      getProfile: () => QUALITY_PROFILES["720p30"],
-      reconcileChildren: () => undefined,
-      send: () => true,
-      onCodecPublisherPrepared: (result) => prepared.push(result),
-      createPublisher: () => ({
-        ...createFakePublisher([], "failed-codec-publisher"),
-        activate: vi.fn(async () => false),
-      }),
-    });
-
-    route.setPaused(true);
-    route.accept({
-      revision: 5,
-      phase: "prepare",
-      assignment: hostAssignment("failed-publication"),
-      candidate: candidate(
-        5,
-        "viewer_12345678",
-        "sfu",
-        "candidate_5_12345678",
-        { generation: 13, videoCodec: "vp8" },
-      ),
-    });
-    await route.acceptConfig(sfuConfig(5));
-
-    expect(prepared).toEqual([
-      {
-        generation: 13,
-        videoCodec: "vp8",
-        binding: {
-          kind: "sfu",
-          publicationGeneration: "failed-publication",
-        },
-        accepted: false,
-      },
-    ]);
-  });
 
   it("reconciles paused Host active truth by exact SFU publication", async () => {
-    let releaseOldPublisher!: () => void;
-    const oldPublisherRetired = new Promise<void>((resolve) => {
-      releaseOldPublisher = resolve;
-    });
     const reconciledChildren: string[][] = [];
-    const disconnectedCallbacks: Array<() => void> = [];
-    const messages: ClientMessage[] = [];
     const publishers: ReturnType<typeof createFakePublisher>[] = [];
     const route = new HostSfuRoute({
       getStream: () => ({}) as MediaStream,
       getProfile: () => QUALITY_PROFILES["720p30"],
       reconcileChildren: (children) => reconciledChildren.push(children),
-      send: (message) => {
-        messages.push(message);
-        return true;
-      },
-      createPublisher: (onDisconnected) => {
-        disconnectedCallbacks.push(onDisconnected);
+      send: () => true,
+      createPublisher: () => {
         const publisher = createFakePublisher(
           [],
           `publisher-${publishers.length + 1}`,
         );
-        if (publishers.length === 0) {
-          publisher.deactivate.mockImplementation(async () => {
-            await oldPublisherRetired;
-            return true;
-          });
-          publisher.disconnect.mockImplementation(async () => {
-            onDisconnected();
-          });
-        }
         publishers.push(publisher);
         return publisher;
       },
@@ -500,53 +345,21 @@ describe("minimal route transition contracts", () => {
         assignment: hostAssignment("publication-old", ["retained-child"]),
       }),
     ).toBe("duplicate");
-    expect(publishers[0]?.disconnect).not.toHaveBeenCalled();
 
-    const retiringOldPublication = route.acceptAndWait({
+    await route.acceptAndWait({
       revision: 3,
       phase: "active",
       assignment: hostAssignment(null, ["retained-child"]),
     });
-    disconnectedCallbacks[0]?.();
-
-    route.accept({
-      revision: 4,
-      phase: "prepare",
-      assignment: hostAssignment("publication-fresh", ["retained-child"]),
-      candidate: candidate(
-        4,
-        "viewer_12345678",
-        "sfu",
-        "candidate_4_12345678",
-        { generation: 15, videoCodec: "vp8" },
-      ),
-    });
-    const freshPublication = route.acceptConfig(sfuConfig(4));
-    await vi.waitFor(() => expect(publishers).toHaveLength(2));
-    expect(publishers[1]?.connect).toHaveBeenCalledOnce();
-    expect(publishers[1]?.activate).not.toHaveBeenCalled();
-    releaseOldPublisher();
-    await Promise.all([retiringOldPublication, freshPublication]);
+    expect(publishers[0]?.deactivate).toHaveBeenCalledOnce();
     expect(publishers[0]?.disconnect).toHaveBeenCalledOnce();
-    expect(publishers[1]?.activate).toHaveBeenCalledOnce();
-    disconnectedCallbacks[0]?.();
-    expect(
-      messages.filter((message) => message.type === "route-failed"),
-    ).toEqual([]);
-
-    route.setPaused(false);
-    await route.acceptAndWait({
-      revision: 4,
-      phase: "active",
-      assignment: hostAssignment("publication-fresh", ["retained-child"]),
-    });
-    expect(publishers[1]?.disconnect).not.toHaveBeenCalled();
+    expect(reconciledChildren.at(-1)).toEqual(["retained-child"]);
   });
 
   it("does not activate a fresh SFU publisher after its exact route becomes stale", async () => {
-    let releaseOldPublisher!: () => void;
-    const oldPublisherRetired = new Promise<void>((resolve) => {
-      releaseOldPublisher = resolve;
+    let releaseFreshPublisher!: () => void;
+    const freshPublisherGate = new Promise<void>((resolve) => {
+      releaseFreshPublisher = resolve;
     });
     const publishers: ReturnType<typeof createFakePublisher>[] = [];
     const route = new HostSfuRoute({
@@ -559,9 +372,9 @@ describe("minimal route transition contracts", () => {
           [],
           `publisher-${publishers.length + 1}`,
         );
-        if (publishers.length === 0) {
-          publisher.deactivate.mockImplementation(async () => {
-            await oldPublisherRetired;
+        if (publishers.length === 1) {
+          publisher.activate.mockImplementation(async () => {
+            await freshPublisherGate;
             return true;
           });
         }
@@ -576,106 +389,36 @@ describe("minimal route transition contracts", () => {
       assignment: hostAssignment("publication-old"),
     });
     await route.acceptConfig(sfuConfig(1));
-    route.setPaused(true);
-    const retiringOldPublication = route.acceptAndWait({
-      revision: 2,
-      phase: "active",
-      assignment: hostAssignment(null),
-    });
-    await vi.waitFor(() =>
-      expect(publishers[0]?.deactivate).toHaveBeenCalledOnce(),
-    );
 
     route.accept({
-      revision: 3,
+      revision: 2,
       phase: "prepare",
       assignment: hostAssignment("publication-fresh"),
-      candidate: candidate(
-        3,
-        "viewer_12345678",
-        "sfu",
-        "candidate_3_12345678",
-        { generation: 17, videoCodec: "h264" },
-      ),
-    });
-    const freshPublication = route.acceptConfig(sfuConfig(3));
-    await vi.waitFor(() => expect(publishers).toHaveLength(2));
-    expect(publishers[1]?.activate).not.toHaveBeenCalled();
-
-    const stalePublication = route.acceptAndWait({
-      revision: 4,
-      phase: "active",
-      assignment: hostAssignment(null),
-    });
-    releaseOldPublisher();
-    await Promise.all([
-      retiringOldPublication,
-      freshPublication,
-      stalePublication,
-    ]);
-
-    expect(publishers[1]?.activate).not.toHaveBeenCalled();
-    expect(publishers[1]?.disconnect).toHaveBeenCalledOnce();
-  });
-
-  it("rejects a tagged codec candidate that reuses the active SFU publication", async () => {
-    const messages: ClientMessage[] = [];
-    const prepared: unknown[] = [];
-    const publishers: ReturnType<typeof createFakePublisher>[] = [];
-    const route = new HostSfuRoute({
-      getStream: () => ({}) as MediaStream,
-      getProfile: () => QUALITY_PROFILES["720p30"],
-      reconcileChildren: () => undefined,
-      send: (message) => {
-        messages.push(message);
-        return true;
-      },
-      onCodecPublisherPrepared: (result) => prepared.push(result),
-      createPublisher: () => {
-        const publisher = createFakePublisher([], "publisher");
-        publishers.push(publisher);
-        return publisher;
-      },
-    });
-
-    await route.acceptAndWait({
-      revision: 1,
-      phase: "active",
-      assignment: hostAssignment("publication-a"),
-    });
-    await route.acceptConfig(sfuConfig(1));
-    route.setPaused(true);
-    route.accept({
-      revision: 2,
-      phase: "prepare",
-      assignment: hostAssignment("publication-a"),
       candidate: candidate(
         2,
         "viewer_12345678",
         "sfu",
         "candidate_2_12345678",
-        { generation: 14, videoCodec: "h264" },
       ),
     });
-    await route.acceptConfig(sfuConfig(2));
+    const freshPublication = route.acceptConfig(sfuConfig(2));
+    await vi.waitFor(() =>
+      expect(publishers[1]?.activate).toHaveBeenCalledOnce(),
+    );
 
-    expect(publishers).toHaveLength(1);
-    expect(prepared).toEqual([
-      {
-        generation: 14,
-        videoCodec: "h264",
-        binding: { kind: "sfu", publicationGeneration: "publication-a" },
-        accepted: false,
-      },
-    ]);
-    expect(messages.at(-1)).toEqual({
-      type: "route-failed",
-      revision: 2,
-      phase: "prepare",
-      connectionId: null,
+    const staleRoute = route.acceptAndWait({
+      revision: 3,
+      phase: "active",
+      assignment: hostAssignment("publication-old"),
     });
+    releaseFreshPublisher();
+    await Promise.all([freshPublication, staleRoute]);
+
+    expect(publishers[0]?.disconnect).not.toHaveBeenCalled();
+    expect(publishers[1]?.disconnect).toHaveBeenCalled();
   });
 
+
   it("uses the subscriber first decoded frame as the only SFU prepare ready", async () => {
     const log: string[] = [];
     const messages: ClientMessage[] = [];
@@ -774,66 +517,6 @@ describe("minimal route transition contracts", () => {
     expect(messages.filter((message) => message.type === "route-ready")).toEqual([]);
   });
 
-  it("keeps a tagged SFU subscriber while paused and waits for a post-resume frame", async () => {
-    const messages: ClientMessage[] = [];
-    let subscriber!: ReturnType<typeof createFakeSubscriber>;
-    const route = new ViewerSfuRoute("viewer_12345678", {
-      activatePeer: () => true,
-      reconcileSfuChildren: () => undefined,
-      onSfuStream: () => undefined,
-      send: (message) => {
-        messages.push(message);
-        return true;
-      },
-      createSubscriber: (events) => {
-        subscriber = createFakeSubscriber(events, [], "codec-subscriber");
-        return subscriber;
-      },
-    });
-
-    route.setPaused(true);
-    route.accept({
-      revision: 4,
-      phase: "prepare",
-      assignment: viewerSfuAssignment([], "fresh-publication"),
-      candidate: candidate(
-        4,
-        "viewer_12345678",
-        "sfu",
-        "candidate_4_12345678",
-        { generation: 12, videoCodec: "vp8" },
-      ),
-    });
-    await route.acceptConfig(sfuConfig(4));
-    expect(subscriber.connect).toHaveBeenCalledOnce();
-    expect(subscriber.activate).toHaveBeenCalledOnce();
-    expect(subscriber.armDecodedFrameProof).not.toHaveBeenCalled();
-
-    subscriber.events.onStream({} as MediaStream);
-    subscriber.events.onFirstDecodedFrame();
-    expect(messages.filter((message) => message.type === "route-ready")).toEqual([]);
-
-    route.setPaused(false);
-    expect(subscriber.armDecodedFrameProof).toHaveBeenLastCalledWith(true);
-    subscriber.events.onFirstDecodedFrame();
-    expect(messages.filter((message) => message.type === "route-ready")).toEqual([
-      { type: "route-ready", revision: 4, phase: "prepare" },
-    ]);
-
-    route.setPaused(true);
-    expect(subscriber.stopDecodedFrameProof).toHaveBeenCalled();
-    subscriber.events.onFirstDecodedFrame();
-    route.setPaused(false);
-    expect(subscriber.armDecodedFrameProof).toHaveBeenLastCalledWith(true);
-    expect(messages.filter((message) => message.type === "route-ready")).toEqual([
-      { type: "route-ready", revision: 4, phase: "prepare" },
-    ]);
-    subscriber.events.onFirstDecodedFrame();
-    expect(messages.filter((message) => message.type === "route-ready")).toEqual([
-      { type: "route-ready", revision: 4, phase: "prepare" },
-      { type: "route-ready", revision: 4, phase: "prepare" },
-    ]);
-  });
 
   it("retires only an unreferenced paused Viewer SFU slot", async () => {
     const messages: ClientMessage[] = [];
@@ -910,37 +593,5 @@ describe("minimal route transition contracts", () => {
     expect(activatedPeers.at(-1)).toEqual(
       peerAssignment("retained-parent", ["retained-child"]),
     );
-
-    route.accept({
-      revision: 4,
-      phase: "prepare",
-      assignment: viewerSfuAssignment(
-        ["retained-child"],
-        "publication-fresh",
-      ),
-      candidate: candidate(
-        4,
-        "viewer_12345678",
-        "sfu",
-        "candidate_4_12345678",
-        { generation: 16, videoCodec: "h264" },
-      ),
-    });
-    await route.acceptConfig(sfuConfig(4));
-    subscribers[0]?.events.onDisconnected();
-    subscribers[1]?.events.onStream({} as MediaStream);
-    subscribers[1]?.events.onFirstDecodedFrame();
-    expect(messages.filter((message) => message.type === "route-ready")).toEqual([]);
-    expect(
-      messages.filter((message) => message.type === "route-failed"),
-    ).toEqual([]);
-
-    route.setPaused(false);
-    expect(subscribers[1]?.armDecodedFrameProof).toHaveBeenLastCalledWith(true);
-    subscribers[1]?.events.onFirstDecodedFrame();
-    expect(messages.filter((message) => message.type === "route-ready")).toEqual([
-      { type: "route-ready", revision: 4, phase: "prepare" },
-    ]);
-    expect(subscribers[1]?.disconnect).not.toHaveBeenCalled();
   });
 });
diff --git a/tests/server-signal.test.ts b/tests/server-signal.test.ts
index 3818853..0f54912 100644
--- a/tests/server-signal.test.ts
+++ b/tests/server-signal.test.ts
@@ -7,6 +7,7 @@ import {
   MAX_SIGNAL_BYTES,
   SIGNALING_PROTOCOL,
   decodeServerMessage,
+  type QualitySettings,
   type Role,
   type ServerMessage,
 } from "../src/shared/protocol.ts";
@@ -256,6 +257,7 @@ async function authenticate(
     viewerPassword?: string;
     codeOnly?: true;
     sharingPaused?: boolean;
+    qualitySettings?: QualitySettings;
   } = {},
 ) {
   client.socket.send(
@@ -272,6 +274,9 @@ async function authenticate(
             ...(presence.sharingPaused !== undefined
               ? { sharingPaused: presence.sharingPaused }
               : {}),
+            ...(presence.qualitySettings
+              ? { qualitySettings: presence.qualitySettings }
+              : {}),
             ...(presence.viewerPresence ? { viewerPresence: true } : {}),
             ...(presence.viewerPasswordSettings
               ? { viewerPasswordSettings: true }
@@ -1355,7 +1360,6 @@ describe("WebSocket signaling", () => {
         payload: {
           kind: "description",
           connectionId: "persistence-failure-edge",
-          negotiationGeneration: null,
           description: { type: "offer", sdp: "v=0\r\n" },
         },
       }),
@@ -1495,31 +1499,11 @@ describe("WebSocket signaling", () => {
 
     activeHost.socket.send(
       JSON.stringify({
-        type: "request-sharing-resume",
+        type: "set-sharing-paused",
         shareGeneration,
+        paused: false,
       }),
     );
-    const resumeAuthorization = await activeHost.inbox.next(
-      "sharing-resume-authorized",
-    );
-    expect(resumeAuthorization).toMatchObject({
-      shareGeneration,
-      codecGeneration: null,
-      resumeAttempt: expect.any(Number),
-    });
-    await replacement.inbox.expectNone(20);
-    activeHost.socket.send(
-      JSON.stringify({
-        type: "sharing-source-enabled",
-        shareGeneration,
-        codecGeneration: null,
-        resumeAttempt: resumeAuthorization.resumeAttempt,
-      }),
-    );
-    expect(await activeHost.inbox.next("host-status")).toMatchObject({
-      online: true,
-      paused: false,
-    });
     expect(await replacement.inbox.next("host-status")).toMatchObject({
       online: true,
       paused: false,
@@ -1564,15 +1548,15 @@ describe("WebSocket signaling", () => {
     });
   });
 
-  it("keeps ordinary P2P Resume paused until the exact source ack", async () => {
-    const harness = await startHarness({ peerAssistedMedia: false });
-    const shareGeneration = "ordinary_resume_share_generation_12345678";
+  it("applies symmetric pause updates only to the exact current Host share", async () => {
+    const harness = await startHarness({ peerAssistedMedia: true });
+    const shareGeneration = "hybrid_pause_share_generation_12345678";
     const host = await openClient(harness.webSocketUrl);
     await authenticate(
       host,
       harness.room,
       "host",
-      "ordinary-resume-host-client",
+      "hybrid-pause-host-client",
       1,
       shareGeneration,
     );
@@ -1581,81 +1565,46 @@ describe("WebSocket signaling", () => {
       viewer,
       harness.room,
       "viewer",
-      "ordinary-resume-viewer-client",
+      "hybrid-pause-viewer-client",
     );
-    await host.inbox.next("peer-joined");
-
-    const pause = {
-      type: "set-sharing-paused",
-      shareGeneration,
-      paused: true,
-    };
-    host.socket.send(JSON.stringify(pause));
-    expect(await viewer.inbox.next("host-status")).toMatchObject({
-      paused: true,
-    });
-    host.socket.send(
-      JSON.stringify({ type: "request-sharing-resume", shareGeneration }),
-    );
-    const first = await host.inbox.next("sharing-resume-authorized");
-    await viewer.inbox.expectNone(20);
-
-    host.socket.send(JSON.stringify(pause));
-    expect(await viewer.inbox.next("host-status")).toMatchObject({
-      paused: true,
-    });
-    host.socket.send(
-      JSON.stringify({ type: "request-sharing-resume", shareGeneration }),
-    );
-    const second = await host.inbox.next("sharing-resume-authorized");
-    expect(second.resumeAttempt).toBeGreaterThan(first.resumeAttempt);
 
     host.socket.send(
       JSON.stringify({
-        type: "sharing-source-enabled",
+        type: "set-sharing-paused",
         shareGeneration,
-        codecGeneration: null,
-        resumeAttempt: first.resumeAttempt,
+        paused: true,
       }),
     );
-    expect(await host.inbox.next("pause-sharing-source")).toMatchObject({
-      shareGeneration,
-      codecGeneration: null,
-      resumeAttempt: first.resumeAttempt,
-    });
-    await viewer.inbox.expectNone(20);
-
-    host.socket.send(
-      JSON.stringify({
-        type: "sharing-source-enabled",
-        shareGeneration,
-        codecGeneration: null,
-        resumeAttempt: second.resumeAttempt,
-      }),
-    );
-    expect(await host.inbox.next("host-status")).toMatchObject({
+    expect(await viewer.inbox.next("host-status")).toMatchObject({
       online: true,
-      paused: false,
+      paused: true,
     });
+    host.socket.send(
+      JSON.stringify({
+        type: "set-sharing-paused",
+        shareGeneration,
+        paused: false,
+      }),
+    );
     expect(await viewer.inbox.next("host-status")).toMatchObject({
       online: true,
       paused: false,
     });
+
+    const closed = new Promise<number>((resolve) =>
+      host.socket.once("close", (code) => resolve(code)),
+    );
     host.socket.send(
       JSON.stringify({
-        type: "sharing-source-enabled",
-        shareGeneration,
-        codecGeneration: null,
-        resumeAttempt: first.resumeAttempt,
+        type: "set-sharing-paused",
+        shareGeneration: "stale_pause_share_generation_12345678",
+        paused: true,
       }),
     );
-    await Promise.all([
-      host.inbox.expectNone(20),
-      viewer.inbox.expectNone(20),
-    ]);
+    expect(await closed).toBe(4001);
   });
 
-  it("retains authoritative pause when a Resume ack is lost across Host reconnect", async () => {
+  it("retains authoritative pause when a reconnecting Host advertises unpaused", async () => {
     const harness = await startHarness({ peerAssistedMedia: false });
     const shareGeneration = "reconnect_resume_share_generation_12345678";
     const hostClientId = "reconnect-resume-host-client";
@@ -1688,13 +1637,6 @@ describe("WebSocket signaling", () => {
       online: true,
       paused: true,
     });
-    host.socket.send(
-      JSON.stringify({ type: "request-sharing-resume", shareGeneration }),
-    );
-    const lostAuthorization = await host.inbox.next(
-      "sharing-resume-authorized",
-    );
-
     await closeClient(host);
     expect(await viewer.inbox.next("host-status")).toMatchObject({
       online: false,
@@ -1713,43 +1655,162 @@ describe("WebSocket signaling", () => {
     );
     expect(
       await reconnectedHost.inbox.next("pause-sharing-source"),
-    ).toMatchObject({
+    ).toEqual({
+      type: "pause-sharing-source",
       shareGeneration,
-      codecGeneration: null,
-      resumeAttempt: null,
     });
     expect(await viewer.inbox.next("host-status")).toMatchObject({
       online: true,
       paused: true,
     });
 
-    reconnectedHost.socket.send(
-      JSON.stringify({ type: "request-sharing-resume", shareGeneration }),
-    );
-    const retryAuthorization = await reconnectedHost.inbox.next(
-      "sharing-resume-authorized",
-    );
-    expect(retryAuthorization.resumeAttempt).toBeGreaterThan(
-      lostAuthorization.resumeAttempt,
-    );
     reconnectedHost.socket.send(
       JSON.stringify({
-        type: "sharing-source-enabled",
+        type: "set-sharing-paused",
         shareGeneration,
-        codecGeneration: null,
-        resumeAttempt: retryAuthorization.resumeAttempt,
+        paused: false,
       }),
     );
-    expect(await reconnectedHost.inbox.next("host-status")).toMatchObject({
-      online: true,
-      paused: false,
-    });
     expect(await viewer.inbox.next("host-status")).toMatchObject({
       online: true,
       paused: false,
     });
   });
 
+  it("binds the new share codec before routing and permits a new choice after stop", async () => {
+    const harness = await startHarness({ peerAssistedMedia: true });
+    const h264Settings: QualitySettings = {
+      resolution: "1080p",
+      maxFramerate: 30,
+      maxBitrate: 5_000_000,
+      degradationPreference: "balanced",
+      videoCodec: "h264",
+      screenAudioQuality: "music",
+    };
+    const firstGeneration = "h264_share_generation_12345678";
+    const viewer = await openClient(harness.webSocketUrl);
+    const viewerAuth = peerAssisted(
+      await authenticate(
+        viewer,
+        harness.room,
+        "viewer",
+        "codec-viewer-client",
+      ),
+    );
+    expect(viewerAuth.qualitySettings.videoCodec).toBe("vp8");
+
+    const host = await openClient(harness.webSocketUrl);
+    const hostAuth = peerAssisted(
+      await authenticate(
+        host,
+        harness.room,
+        "host",
+        "codec-host-client",
+        1,
+        firstGeneration,
+        { qualitySettings: h264Settings },
+      ),
+    );
+    expect(hostAuth.qualitySettings).toEqual(h264Settings);
+    expect(await viewer.inbox.next("quality-settings")).toEqual({
+      type: "quality-settings",
+      qualitySettings: h264Settings,
+    });
+
+    const replaced = new Promise<number>((resolve) =>
+      host.socket.once("close", (code) => resolve(code)),
+    );
+    const reconnectedHost = await openClient(harness.webSocketUrl);
+    const reconnectedAuth = peerAssisted(
+      await authenticate(
+        reconnectedHost,
+        harness.room,
+        "host",
+        "codec-host-client",
+        1,
+        firstGeneration,
+        {
+          qualitySettings: {
+            ...h264Settings,
+            videoCodec: "vp8",
+          },
+        },
+      ),
+    );
+    expect(await replaced).toBe(4001);
+    expect(reconnectedAuth.qualitySettings).toEqual(h264Settings);
+    await expect(
+      viewer.inbox.next("quality-settings", 30),
+    ).rejects.toThrow("Timed out");
+
+    const updatedH264Settings: QualitySettings = {
+      ...h264Settings,
+      resolution: "720p",
+      maxBitrate: 3_000_000,
+    };
+    reconnectedHost.socket.send(
+      JSON.stringify({
+        type: "set-quality-settings",
+        qualitySettings: updatedH264Settings,
+      }),
+    );
+    expect(await viewer.inbox.next("quality-settings")).toEqual({
+      type: "quality-settings",
+      qualitySettings: updatedH264Settings,
+    });
+
+    reconnectedHost.socket.send(
+      JSON.stringify({
+        type: "set-quality-settings",
+        qualitySettings: {
+          ...updatedH264Settings,
+          videoCodec: "vp8",
+        },
+      }),
+    );
+    expect(await reconnectedHost.inbox.next("error")).toEqual({
+      type: "error",
+      code: "FORBIDDEN",
+      message: "视频编码只能在开始分享前选择；请停止分享后重新开始",
+    });
+
+    const stopped = new Promise<number>((resolve) =>
+      reconnectedHost.socket.once("close", (code) => resolve(code)),
+    );
+    reconnectedHost.socket.send(
+      JSON.stringify({
+        type: "stop-sharing",
+        shareGeneration: firstGeneration,
+      }),
+    );
+    expect(await stopped).toBe(1000);
+    await viewer.inbox.next("sharing-stopped");
+
+    const vp8Settings: QualitySettings = {
+      ...updatedH264Settings,
+      videoCodec: "vp8",
+    };
+    const nextHost = await openClient(harness.webSocketUrl);
+    const nextAuth = peerAssisted(
+      await authenticate(
+        nextHost,
+        harness.room,
+        "host",
+        "codec-host-client",
+        1,
+        "vp8_share_generation_12345678",
+        {
+          qualitySettings: vp8Settings,
+        },
+      ),
+    );
+    expect(nextAuth.qualitySettings).toEqual(vp8Settings);
+    expect(await viewer.inbox.next("quality-settings")).toEqual({
+      type: "quality-settings",
+      qualitySettings: vp8Settings,
+    });
+  });
+
   it("keeps a viewer peer stable when it reconnects inside the grace period", async () => {
     const harness = await startHarness({ viewerDisconnectGraceMs: 80 });
     const host = await openClient(harness.webSocketUrl);
@@ -1769,7 +1830,6 @@ describe("WebSocket signaling", () => {
         payload: {
           kind: "description",
           connectionId: "stable-connection",
-          negotiationGeneration: null,
           description: { type: "offer", sdp: "v=0\r\n" },
         },
       }),
@@ -1883,7 +1943,6 @@ describe("WebSocket signaling", () => {
           payload: {
             kind: "description",
             connectionId: "waiting-host-offer",
-            negotiationGeneration: null,
             description: { type: "offer", sdp: "v=0\r\n" },
           },
         }),
@@ -1910,7 +1969,6 @@ describe("WebSocket signaling", () => {
           payload: {
             kind: "description",
             connectionId: "waiting-viewer-answer",
-            negotiationGeneration: null,
             description: { type: "answer", sdp: "v=0\r\n" },
           },
         }),
@@ -1945,7 +2003,6 @@ describe("WebSocket signaling", () => {
           payload: {
             kind: "description",
             connectionId: "active-host-offer",
-            negotiationGeneration: null,
             description: { type: "offer", sdp: "v=0\r\n" },
           },
         }),
@@ -2049,7 +2106,6 @@ describe("WebSocket signaling", () => {
         payload: {
           kind: "description",
           connectionId: "promoted-host-offer",
-          negotiationGeneration: null,
           description: { type: "offer", sdp: "v=0\r\n" },
         },
       }),
@@ -2081,7 +2137,6 @@ describe("WebSocket signaling", () => {
         payload: {
           kind: "description",
           connectionId: "connection-before-stop",
-          negotiationGeneration: null,
           description: { type: "offer", sdp: "v=0\r\n" },
         },
       }),
@@ -2225,7 +2280,6 @@ describe("WebSocket signaling", () => {
         payload: {
           kind: "description",
           connectionId: "connection-before-control-outage",
-          negotiationGeneration: null,
           description: { type: "offer", sdp: "v=0\r\n" },
         },
       }),
@@ -2335,7 +2389,6 @@ describe("WebSocket signaling", () => {
         payload: {
           kind: "description",
           connectionId: "connection-during-grace",
-          negotiationGeneration: null,
           description: { type: "offer", sdp: "v=0\r\n" },
         },
       }),
@@ -2514,26 +2567,26 @@ describe("WebSocket signaling", () => {
     expect(await closeCode).toBe(1009);
   });
 
-  it("terminates an old client protocol before authentication", async () => {
+  it("terminates an invalid protocol before authentication", async () => {
     const harness = await startHarness();
-    const oldClient = await openClient(harness.webSocketUrl);
+    const invalidClient = await openClient(harness.webSocketUrl);
     const closed = new Promise<{ code: number; reason: string }>((resolve) =>
-      oldClient.socket.once("close", (code, reason) =>
+      invalidClient.socket.once("close", (code, reason) =>
         resolve({ code, reason: reason.toString() }),
       ),
     );
 
-    oldClient.socket.send(
+    invalidClient.socket.send(
       JSON.stringify({
         type: "authenticate",
-        protocol: "screener-v5",
+        protocol: "invalid-protocol",
         roomId: "999999999999",
         role: "viewer",
-        clientId: "old-client",
+        clientId: "invalid-client",
       }),
     );
 
-    expect(await oldClient.inbox.next("error")).toMatchObject({
+    expect(await invalidClient.inbox.next("error")).toMatchObject({
       code: "INVALID_MESSAGE",
     });
     expect(await closed).toEqual({ code: 1008, reason: "Invalid message" });
diff --git a/tests/sfu-client.test.ts b/tests/sfu-client.test.ts
index a8ddec3..96e3976 100644
--- a/tests/sfu-client.test.ts
+++ b/tests/sfu-client.test.ts
@@ -603,6 +603,7 @@ describe("SfuPublisher", () => {
     expect(room.localParticipant.publishTrack).toHaveBeenNthCalledWith(1, video, {
       source: Track.Source.ScreenShare,
       backupCodec: false,
+      videoCodec: "vp8",
       simulcast: true,
       screenShareEncoding: {
         maxBitrate: 8_000_000,
@@ -622,7 +623,7 @@ describe("SfuPublisher", () => {
     });
     expect(
       room.localParticipant.publishTrack.mock.calls[0]?.[1],
-    ).not.toHaveProperty("videoCodec");
+    ).toHaveProperty("videoCodec", "vp8");
     expect(room.localParticipant.publishTrack).toHaveBeenNthCalledWith(2, audio, {
       source: Track.Source.ScreenShareAudio,
       audioPreset: { maxBitrate: 128_000 },
@@ -716,6 +717,22 @@ describe("SfuPublisher", () => {
     },
   );
 
+  it("leaves the SFU codec unset only for an explicit automatic preference", async () => {
+    const publisher = new SfuPublisher();
+    await publisher.connect(connection);
+
+    await expect(
+      publisher.activate(stream(track("video", "video-1")), {
+        ...qualityProfile,
+        videoCodec: "automatic",
+      }),
+    ).resolves.toBe(true);
+
+    expect(
+      livekit.state.rooms[0].localParticipant.publishTrack.mock.calls[0]?.[1],
+    ).not.toHaveProperty("videoCodec");
+  });
+
   it("fails closed when initial sender configuration is rejected", async () => {
     const disconnected = vi.fn();
     const publisher = new SfuPublisher({ onDisconnected: disconnected });
diff --git a/tests/viewer-peer-generation.test.ts b/tests/viewer-peer-generation.test.ts
index 6762857..3c6fd9d 100644
--- a/tests/viewer-peer-generation.test.ts
+++ b/tests/viewer-peer-generation.test.ts
@@ -133,14 +133,10 @@ const timeoutCallbacks = new Map<number, () => void>();
 const timeoutDelays = new Map<number, number>();
 let nextTimeoutId = 1;
 
-function offer(
-  connectionId: string,
-  negotiationGeneration: number | null = null,
-): SignalPayload {
+function offer(connectionId: string): SignalPayload {
   return {
     kind: "description",
     connectionId,
-    negotiationGeneration,
     description: { type: "offer", sdp: `offer-${connectionId}` },
   };
 }
@@ -666,7 +662,7 @@ describe("ViewerPeer connection generations", () => {
     });
   });
 
-  it("serializes same-connection codec offers and fences stale generations", async () => {
+  it("serializes ordinary offers for the same connection", async () => {
     const firstLocalDescription = createDeferred<void>();
     FakePeerConnection.plans.push({
       localDescriptionGate: firstLocalDescription.promise,
@@ -674,40 +670,23 @@ describe("ViewerPeer connection generations", () => {
     const signals: SignalPayload[] = [];
     const peer = createPeer(signals, []);
 
-    const first = peer.acceptSignal("host", offer("codec-connection", 5));
+    const first = peer.acceptSignal("host", offer("same-connection"));
     await vi.waitFor(() =>
       expect(
         FakePeerConnection.instances[0]?.setLocalDescription,
       ).toHaveBeenCalledOnce(),
     );
     const connection = FakePeerConnection.instances[0]!;
-    const replacement = peer.acceptSignal(
-      "host",
-      offer("codec-connection", 6),
-    );
-    await peer.acceptSignal("host", offer("codec-connection", 6));
+    const second = peer.acceptSignal("host", offer("same-connection"));
     await Promise.resolve();
     expect(connection.setRemoteDescription).toHaveBeenCalledOnce();
 
     firstLocalDescription.resolve();
-    await Promise.all([first, replacement]);
-    expect(
-      signals
-        .filter((signal) => signal.kind === "description")
-        .map((signal) => signal.negotiationGeneration),
-    ).toEqual([6]);
+    await Promise.all([first, second]);
     expect(connection.setRemoteDescription).toHaveBeenCalledTimes(2);
-
-    await peer.acceptSignal("host", offer("codec-connection"));
     expect(
-      signals
-        .filter((signal) => signal.kind === "description")
-        .map((signal) => signal.negotiationGeneration),
-    ).toEqual([6, null]);
-    expect(connection.setRemoteDescription).toHaveBeenCalledTimes(3);
-
-    await peer.acceptSignal("host", offer("codec-connection", 5));
-    expect(connection.setRemoteDescription).toHaveBeenCalledTimes(3);
+      signals.filter((signal) => signal.kind === "description"),
+    ).toHaveLength(2);
   });
 
   it("stops flushing old candidates when the connection is replaced", async () => {