4 files changed, 27 insertions, 21 deletions
diff --git a/object/store/dual/dual.go b/object/store/dual/dual.go
index 627cc121..f95a9194 100644
--- a/object/store/dual/dual.go
+++ b/object/store/dual/dual.go
@@ -32,4 +32,5 @@ var (
 	_ objectstore.PackWriter        = (*Dual)(nil)
 	_ objectstore.ObjectQuarantiner = (*Dual)(nil)
 	_ objectstore.PackQuarantiner   = (*Dual)(nil)
+	_ objectstore.WriterQuarantiner = (*Dual)(nil)
 )
diff --git a/object/store/dual/dual_test.go b/object/store/dual/dual_test.go
index bccd378f..d9401c30 100644
--- a/object/store/dual/dual_test.go
+++ b/object/store/dual/dual_test.go
@@ -117,14 +117,14 @@ func TestDualReadsWritesAndQuarantine(t *testing.T) {
 		repo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
 		store := newDualStore(t, repo, algo)
 
-		quarantiner, ok := any(store).(objectstore.PackQuarantiner)
+		quarantiner, ok := any(store).(objectstore.WriterQuarantiner)
 		if !ok {
-			t.Fatal("dual does not implement PackQuarantiner")
+			t.Fatal("dual does not implement WriterQuarantiner")
 		}
 
-		quarantine, err := quarantiner.BeginPackQuarantine(objectstore.PackQuarantineOptions{})
+		quarantine, err := quarantiner.BeginQuarantine(objectstore.QuarantineOptions{})
 		if err != nil {
-			t.Fatalf("BeginPackQuarantine: %v", err)
+			t.Fatalf("BeginQuarantine: %v", err)
 		}
 
 		err = quarantine.WritePack(bytes.NewReader(packBytes), objectstore.PackWriteOptions{RequireTrailingEOF: true})
@@ -219,18 +219,13 @@ func TestDualQuarantineDiscardDropsBothHalves(t *testing.T) {
 		repo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
 		store := newDualStore(t, repo, algo)
 
-		quarantiner := any(store).(objectstore.ObjectQuarantiner)
-		quarantine, err := quarantiner.BeginObjectQuarantine(objectstore.ObjectQuarantineOptions{})
+		quarantiner := any(store).(objectstore.WriterQuarantiner)
+		quarantine, err := quarantiner.BeginQuarantine(objectstore.QuarantineOptions{})
 		if err != nil {
-			t.Fatalf("BeginObjectQuarantine: %v", err)
+			t.Fatalf("BeginQuarantine: %v", err)
 		}
 
-		packQ, ok := any(quarantine).(objectstore.PackQuarantine)
-		if !ok {
-			t.Fatal("object quarantine does not also implement PackQuarantine")
-		}
-
-		err = packQ.WritePack(bytes.NewReader(packBytes), objectstore.PackWriteOptions{RequireTrailingEOF: true})
+		err = quarantine.WritePack(bytes.NewReader(packBytes), objectstore.PackWriteOptions{RequireTrailingEOF: true})
 		if err != nil {
 			t.Fatalf("quarantine.WritePack: %v", err)
 		}
diff --git a/object/store/dual/quarantine.go b/object/store/dual/quarantine.go
index ff561c7c..6fabd590 100644
--- a/object/store/dual/quarantine.go
+++ b/object/store/dual/quarantine.go
@@ -19,6 +19,7 @@ type quarantine struct {
 var (
 	_ objectstore.ObjectQuarantine = (*quarantine)(nil)
 	_ objectstore.PackQuarantine   = (*quarantine)(nil)
+	_ objectstore.WriterQuarantine = (*quarantine)(nil)
 )
 
 func newQuarantine(
diff --git a/object/store/dual/quarantine_begin.go b/object/store/dual/quarantine_begin.go
index bca688b7..cd516c3e 100644
--- a/object/store/dual/quarantine_begin.go
+++ b/object/store/dual/quarantine_begin.go
@@ -2,14 +2,21 @@ package dual
 
 import objectstore "codeberg.org/lindenii/furgit/object/store"
 
-// TODO: This doesn't actually make sense. We need a combined quarantine.
+// BeginQuarantine creates one coordinated dual quarantine spanning both stores.
+//
+// Labels: Deps-Borrowed, Life-Parent, Close-No.
+func (dual *Dual) BeginQuarantine(opts objectstore.QuarantineOptions) (objectstore.WriterQuarantine, error) {
+	return dual.beginQuarantine(opts)
+}
 
 // BeginObjectQuarantine creates one coordinated dual quarantine spanning both
 // stores and returns it as an object-wise quarantine.
 //
 // Labels: Deps-Borrowed, Life-Parent, Close-No.
-func (dual *Dual) BeginObjectQuarantine(_ objectstore.ObjectQuarantineOptions) (objectstore.ObjectQuarantine, error) {
-	quarantine, err := dual.beginQuarantine()
+func (dual *Dual) BeginObjectQuarantine(opts objectstore.ObjectQuarantineOptions) (objectstore.ObjectQuarantine, error) {
+	quarantine, err := dual.beginQuarantine(objectstore.QuarantineOptions{
+		Object: opts,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -21,8 +28,10 @@ func (dual *Dual) BeginObjectQuarantine(_ objectstore.ObjectQuarantineOptions) (
 // stores and returns it as a pack-wise quarantine.
 //
 // Labels: Deps-Borrowed, Life-Parent, Close-No.
-func (dual *Dual) BeginPackQuarantine(_ objectstore.PackQuarantineOptions) (objectstore.PackQuarantine, error) {
-	quarantine, err := dual.beginQuarantine()
+func (dual *Dual) BeginPackQuarantine(opts objectstore.PackQuarantineOptions) (objectstore.PackQuarantine, error) {
+	quarantine, err := dual.beginQuarantine(objectstore.QuarantineOptions{
+		Pack: opts,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -30,13 +39,13 @@ func (dual *Dual) BeginPackQuarantine(_ objectstore.PackQuarantineOptions) (obje
 	return quarantine, nil
 }
 
-func (dual *Dual) beginQuarantine() (*quarantine, error) {
-	objectQ, err := dual.object.BeginObjectQuarantine(objectstore.ObjectQuarantineOptions{})
+func (dual *Dual) beginQuarantine(opts objectstore.QuarantineOptions) (*quarantine, error) {
+	objectQ, err := dual.object.BeginObjectQuarantine(opts.Object)
 	if err != nil {
 		return nil, err
 	}
 
-	packQ, err := dual.pack.BeginPackQuarantine(objectstore.PackQuarantineOptions{})
+	packQ, err := dual.pack.BeginPackQuarantine(opts.Pack)
 	if err != nil {
 		_ = objectQ.Discard()