diff --git a/metropolis/installer/BUILD.bazel b/metropolis/installer/BUILD.bazel
index 5792326..fe80669 100644
--- a/metropolis/installer/BUILD.bazel
+++ b/metropolis/installer/BUILD.bazel
@@ -16,6 +16,7 @@
         "//osbase/bringup",
         "//osbase/build/mkimage/osimage",
         "//osbase/efivarfs",
+        "//osbase/structfs",
         "//osbase/supervisor",
         "//osbase/sysfs",
         "@org_golang_x_sys//unix",
diff --git a/metropolis/installer/main.go b/metropolis/installer/main.go
index e9956fd..216f99c 100644
--- a/metropolis/installer/main.go
+++ b/metropolis/installer/main.go
@@ -8,12 +8,10 @@
 
 import (
 	"archive/zip"
-	"bytes"
 	"context"
 	_ "embed"
 	"errors"
 	"fmt"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -25,6 +23,7 @@
 	"source.monogon.dev/osbase/bringup"
 	"source.monogon.dev/osbase/build/mkimage/osimage"
 	"source.monogon.dev/osbase/efivarfs"
+	"source.monogon.dev/osbase/structfs"
 	"source.monogon.dev/osbase/supervisor"
 	"source.monogon.dev/osbase/sysfs"
 )
@@ -104,19 +103,22 @@
 	return suitable, nil
 }
 
-// FileSizedReader is a small adapter from fs.File to fs.SizedReader
-// Panics on Stat() failure, so should only be used with sources where Stat()
-// cannot fail.
-type FileSizedReader struct {
-	fs.File
+// zipBlob looks up a file in a [zip.Reader] and adapts it to [structfs.Blob].
+func zipBlob(reader *zip.Reader, name string) (zipFileBlob, error) {
+	for _, file := range reader.File {
+		if file.Name == name {
+			return zipFileBlob{file}, nil
+		}
+	}
+	return zipFileBlob{}, fmt.Errorf("file %q not found", name)
 }
 
-func (f FileSizedReader) Size() int64 {
-	stat, err := f.Stat()
-	if err != nil {
-		panic(err)
-	}
-	return stat.Size()
+type zipFileBlob struct {
+	*zip.File
+}
+
+func (f zipFileBlob) Size() int64 {
+	return int64(f.File.UncompressedSize64)
 }
 
 func main() {
@@ -162,7 +164,7 @@
 		return fmt.Errorf("while mounting the installer ESP: %w", err)
 	}
 
-	nodeParameters, err := os.Open("/installer/metropolis-installer/nodeparams.pb")
+	nodeParameters, err := structfs.OSPathBlob("/installer/metropolis-installer/nodeparams.pb")
 	if err != nil {
 		return fmt.Errorf("failed to open node parameters from ESP: %w", err)
 	}
@@ -173,16 +175,14 @@
 		return fmt.Errorf("failed to open node bundle from ESP: %w", err)
 	}
 	defer bundle.Close()
-	efiPayload, err := bundle.Open("kernel_efi.efi")
+	efiPayload, err := zipBlob(&bundle.Reader, "kernel_efi.efi")
 	if err != nil {
 		return fmt.Errorf("cannot open EFI payload in bundle: %w", err)
 	}
-	defer efiPayload.Close()
-	systemImage, err := bundle.Open("verity_rootfs.img")
+	systemImage, err := zipBlob(&bundle.Reader, "verity_rootfs.img")
 	if err != nil {
 		return fmt.Errorf("cannot open system image in bundle: %w", err)
 	}
-	defer systemImage.Close()
 
 	// Build the osimage parameters.
 	installParams := osimage.Params{
@@ -198,9 +198,9 @@
 			Data: 128,
 		},
 		SystemImage:    systemImage,
-		EFIPayload:     FileSizedReader{efiPayload},
-		ABLoader:       bytes.NewReader(abloader),
-		NodeParameters: FileSizedReader{nodeParameters},
+		EFIPayload:     efiPayload,
+		ABLoader:       structfs.Bytes(abloader),
+		NodeParameters: nodeParameters,
 	}
 	// Calculate the minimum target size based on the installation parameters.
 	minSize := uint64((installParams.PartitionSize.ESP +
diff --git a/metropolis/installer/test/BUILD.bazel b/metropolis/installer/test/BUILD.bazel
index 7f7ad54..7b7828d 100644
--- a/metropolis/installer/test/BUILD.bazel
+++ b/metropolis/installer/test/BUILD.bazel
@@ -24,6 +24,7 @@
         "//metropolis/proto/api",
         "//osbase/build/mkimage/osimage",
         "//osbase/cmd",
+        "//osbase/structfs",
         "@com_github_diskfs_go_diskfs//:go-diskfs",
         "@com_github_diskfs_go_diskfs//disk",
         "@com_github_diskfs_go_diskfs//partition/gpt",
diff --git a/metropolis/installer/test/run_test.go b/metropolis/installer/test/run_test.go
index 766c839..cd87852 100644
--- a/metropolis/installer/test/run_test.go
+++ b/metropolis/installer/test/run_test.go
@@ -7,7 +7,6 @@
 package installer
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"log"
@@ -27,6 +26,7 @@
 	mctl "source.monogon.dev/metropolis/cli/metroctl/core"
 	"source.monogon.dev/osbase/build/mkimage/osimage"
 	"source.monogon.dev/osbase/cmd"
+	"source.monogon.dev/osbase/structfs"
 )
 
 var (
@@ -134,21 +134,21 @@
 func TestMain(m *testing.M) {
 	installerImage = filepath.Join(os.Getenv("TEST_TMPDIR"), "installer.img")
 
-	installer, err := os.ReadFile(xInstallerPath)
+	installer, err := structfs.OSPathBlob(xInstallerPath)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	bundle, err := os.ReadFile(xBundlePath)
+	bundle, err := structfs.OSPathBlob(xBundlePath)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	iargs := mctl.MakeInstallerImageArgs{
-		Installer:  bytes.NewReader(installer),
+		Installer:  installer,
 		TargetPath: installerImage,
 		NodeParams: &api.NodeParameters{},
-		Bundle:     bytes.NewReader(bundle),
+		Bundle:     bundle,
 	}
 	if err := mctl.MakeInstallerImage(iargs); err != nil {
 		log.Fatalf("Couldn't create the installer image at %q: %v", installerImage, err)