@@ -212,6 +212,65 @@ it.effect(
     }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
 );
 
+it.effect("requires an ffmpeg the device hub can encode with before reporting Android ready", () =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-device-ffmpeg-" });
+    for (const [directory, tool] of [
+      ["platform-tools", "adb"],
+      ["emulator", "emulator"],
+      ["cmdline-tools/latest/bin", "avdmanager"],
+    ]) {
+      yield* fs.makeDirectory(`${baseDir}/sdk/${directory}`, { recursive: true });
+      yield* fs.writeFileString(`${baseDir}/sdk/${directory}/${tool}`, "");
+    }
+    let probe = { stdout: " V....D libopenh264", code: 0 };
+    const probed: Array<string> = [];
+    const host = yield* LocalDeviceHost.make().pipe(
+      Effect.provide(Layer.mergeAll(ServerConfig.layerTest(baseDir, baseDir), NetService.layer)),
+      Effect.provideService(HostProcess.Environment, {
+        HOME: baseDir,
+        PATH: "/usr/bin",
+        ANDROID_HOME: `${baseDir}/sdk`,
+      }),
+      Effect.provideService(HostProcess.Platform, "linux"),
+      Effect.provideService(CommandAvailability, () => Effect.succeed(true)),
+      Effect.provideService(
+        HttpClient.HttpClient,
+        HttpClient.make(() => Effect.die(new Error("Readiness must not make network requests"))),
+      ),
+      Effect.provideService(ProcessRunner.ProcessRunner, {
+        run: (input) => {
+          probed.push([input.command, ...input.args].join(" "));
+          return Effect.succeed({
+            ...probe,
+            stderr: "",
+            code: ChildProcessSpawner.ExitCode(probe.code),
+            timedOut: false,
+            stdoutTruncated: false,
+            stderrTruncated: false,
+            stdoutInvalidUtf8: false,
+            stderrInvalidUtf8: false,
+          });
+        },
+      }),
+    );
+    expect((yield* host.platformAvailability("android")).reason).toContain(
+      "lacks the libx264 encoder",
+    );
+    probe = { stdout: "", code: 1 };
+    expect((yield* host.platformAvailability("android")).reason).toContain("could not be run");
+    probe = { stdout: " V....D libx264", code: 0 };
+    expect(yield* host.platformAvailability("android")).toEqual({
+      platform: "android",
+      available: true,
+    });
+    // A usable ffmpeg is probed once, not on every readiness check.
+    yield* host.platformAvailability("android");
+    expect(probed).toEqual(Array.from({ length: 3 }, () => "ffmpeg -hide_banner -encoders"));
+  }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+);
+
 it.effect(
   "constructs and inspects an unconfigured host without installing or starting helpers",
   () =>
 
@@ -251,13 +251,39 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
   const restartDelayRef = yield* Ref.make(0);
   const hostId = LOCAL_DEVICE_HOST_ID;
 
+  let usableFfmpeg: string | null = null;
+  /**
+   * Runs the capability probe the device hub runs before it encodes emulator
+   * video. Only a success is remembered, so installing ffmpeg clears the reason.
+   */
+  const ffmpegEncoderReason = Effect.gen(function* () {
+    const ffmpeg = hostEnvironment.SERVE_EMU_FFMPEG?.trim() || "ffmpeg";
+    if (usableFfmpeg === ffmpeg) return null;
+    const encoders = yield* runner
+      .run({
+        command: ffmpeg,
+        args: ["-hide_banner", "-encoders"],
+        env: hostEnvironment,
+        timeout: Duration.seconds(10),
+        timeoutBehavior: "timedOutResult",
+      })
+      .pipe(Effect.option);
+    if (Option.isNone(encoders) || encoders.value.timedOut || Number(encoders.value.code) !== 0)
+      return `ffmpeg at ${ffmpeg} could not be run. Android emulator video needs a working ffmpeg with the libx264 encoder.`;
+    if (!/\blibx264\b/.test(`${encoders.value.stdout}\n${encoders.value.stderr}`))
+      return `ffmpeg at ${ffmpeg} lacks the libx264 encoder that Android emulator video needs. Install an ffmpeg build that includes libx264.`;
+    usableFfmpeg = ffmpeg;
+    return null;
+  });
+
   const platformAvailability = Effect.fn("LocalDeviceHost.platformAvailability")(function* (
     platform: DevicePlatform,
   ): Effect.fn.Return<DevicePlatformAvailability> {
-    const reason = yield* platformReason(platform).pipe(
-      Effect.provideService(FileSystem.FileSystem, fs),
-      Effect.provideService(Path.Path, path),
-    );
+    const reason =
+      (yield* platformReason(platform).pipe(
+        Effect.provideService(FileSystem.FileSystem, fs),
+        Effect.provideService(Path.Path, path),
+      )) ?? (platform === "android" ? yield* ffmpegEncoderReason : null);
     return reason === null ? { platform, available: true } : { platform, available: false, reason };
   });