diff --git a/actions/domains/assignDomainToDocument.ts b/actions/domains/assignDomainToDocument.ts
index 100cf842..6eaa1d10 100644
--- a/actions/domains/assignDomainToDocument.ts
+++ b/actions/domains/assignDomainToDocument.ts
@@ -24,11 +24,13 @@ export async function assignDomainToDocument({
   if (!identity || !identity.custom_domains.find((d) => d.domain === domain))
     return null;
 
-  await supabase.from("publication_domains").delete().eq("domain", domain);
-  await supabase
-    .from("custom_domain_routes")
-    .delete()
-    .eq("edit_permission_token", edit_permission_token);
+  await Promise.all([
+    supabase.from("publication_domains").delete().eq("domain", domain),
+    supabase
+      .from("custom_domain_routes")
+      .delete()
+      .eq("edit_permission_token", edit_permission_token),
+  ]);
 
   await supabase.from("custom_domain_routes").insert({
     domain,
diff --git a/actions/domains/assignDomainToPublication.ts b/actions/domains/assignDomainToPublication.ts
index 6829f74a..9f35e46c 100644
--- a/actions/domains/assignDomainToPublication.ts
+++ b/actions/domains/assignDomainToPublication.ts
@@ -27,8 +27,10 @@ export async function assignDomainToPublication({
     .single();
   if (publication?.identity_did !== identity.atp_did) return null;
 
-  await supabase.from("custom_domain_routes").delete().eq("domain", domain);
-  await supabase.from("publication_domains").delete().eq("domain", domain);
+  await Promise.all([
+    supabase.from("custom_domain_routes").delete().eq("domain", domain),
+    supabase.from("publication_domains").delete().eq("domain", domain),
+  ]);
 
   await supabase.from("publication_domains").insert({
     publication: publication_uri,
diff --git a/actions/domains/removeDomainAssignment.ts b/actions/domains/removeDomainAssignment.ts
index 4f3ffa48..f35970d7 100644
--- a/actions/domains/removeDomainAssignment.ts
+++ b/actions/domains/removeDomainAssignment.ts
@@ -18,8 +18,10 @@ export async function removeDomainAssignment({
   if (!identity || !identity.custom_domains.find((d) => d.domain === domain))
     return null;
 
-  await supabase.from("custom_domain_routes").delete().eq("domain", domain);
-  await supabase.from("publication_domains").delete().eq("domain", domain);
+  await Promise.all([
+    supabase.from("custom_domain_routes").delete().eq("domain", domain),
+    supabase.from("publication_domains").delete().eq("domain", domain),
+  ]);
 
   return true;
 }
diff --git a/actions/domains/removeDomainRoute.ts b/actions/domains/removeDomainRoute.ts
new file mode 100644
index 00000000..6a40a5fb
--- /dev/null
+++ b/actions/domains/removeDomainRoute.ts
@@ -0,0 +1,25 @@
+"use server";
+import { Database } from "supabase/database.types";
+import { createServerClient } from "@supabase/ssr";
+import { getIdentityData } from "actions/getIdentityData";
+
+let supabase = createServerClient<Database>(
+  process.env.NEXT_PUBLIC_SUPABASE_API_URL as string,
+  process.env.SUPABASE_SERVICE_ROLE_KEY as string,
+  { cookies: {} },
+);
+
+export async function removeDomainRoute({ routeId }: { routeId: string }) {
+  let identity = await getIdentityData();
+  if (!identity) return null;
+
+  // Verify the route belongs to one of the user's domains
+  let allRoutes = identity.custom_domains.flatMap(
+    (d) => d.custom_domain_routes,
+  );
+  if (!allRoutes.find((r) => r.id === routeId)) return null;
+
+  await supabase.from("custom_domain_routes").delete().eq("id", routeId);
+
+  return true;
+}
diff --git a/app/[leaflet_id]/actions/ShareOptions/DomainOptions.tsx b/app/[leaflet_id]/actions/ShareOptions/DomainOptions.tsx
index 5aedc86d..0338edde 100644
--- a/app/[leaflet_id]/actions/ShareOptions/DomainOptions.tsx
+++ b/app/[leaflet_id]/actions/ShareOptions/DomainOptions.tsx
@@ -2,7 +2,10 @@ import { useState } from "react";
 import { ButtonPrimary } from "components/Buttons";
 import { useToaster } from "components/Toast";
 import { Input } from "components/Input";
-import { useIdentityData } from "components/IdentityProvider";
+import {
+  useIdentityData,
+  mutateIdentityData,
+} from "components/IdentityProvider";
 import { useDomainStatus } from "components/Domains/useDomainStatus";
 import { CustomDomain } from "components/Domains/DomainList";
 import {
@@ -85,25 +88,36 @@ const DomainOptions = (props: {
   let toaster = useToaster();
   let publishLink = useReadOnlyShareLink();
 
-  // Find the CustomDomain object for the selected domain to check its assignment
-  let selectedDomainData = identity?.custom_domains.find(
-    (d: CustomDomain) => d.domain === selectedDomain,
+  // Filter out domains assigned to publications — they can't be used for leaflets
+  let availableDomains = (identity?.custom_domains || []).filter(
+    (d: CustomDomain) => d.publication_domains.length === 0,
   );
-  let selectedAssignment = selectedDomainData
-    ? getDomainAssignment(selectedDomainData)
-    : null;
-  let willReassign =
-    selectedAssignment && selectedAssignment.type !== "unassigned";
-
-  let [confirmingReassign, setConfirmingReassign] = useState(false);
 
   async function doPublish() {
     if (!selectedDomain || !publishLink) return;
-    await assignDomainToDocument({
-      domain: selectedDomain,
-      route: "/" + selectedRoute,
-      view_permission_token: publishLink,
-      edit_permission_token: permission_token.id,
+    let route = "/" + selectedRoute;
+
+    // Optimistic update
+    mutateIdentityData(mutateIdentity, (draft) => {
+      let domain = draft.custom_domains.find(
+        (d) => d.domain === selectedDomain,
+      );
+      if (domain) {
+        // Remove existing route for this leaflet, add new one
+        domain.custom_domain_routes = [
+          ...domain.custom_domain_routes.filter(
+            (r) => r.edit_permission_token !== permission_token.id,
+          ),
+          {
+            id: crypto.randomUUID(),
+            domain: selectedDomain,
+            route,
+            view_permission_token: publishLink,
+            edit_permission_token: permission_token.id,
+            created_at: new Date().toISOString(),
+          },
+        ];
+      }
     });
 
     toaster({
@@ -121,17 +135,22 @@ const DomainOptions = (props: {
       ),
       type: "success",
     });
-    mutateIdentity();
     mutateDomains();
-    setConfirmingReassign(false);
     props.setShareMenuState("default");
+
+    await assignDomainToDocument({
+      domain: selectedDomain,
+      route,
+      view_permission_token: publishLink,
+      edit_permission_token: permission_token.id,
+    });
   }
 
   return (
     <div className="px-3 py-1 flex flex-col gap-3 max-w-full w-[600px]">
       <h3 className="text-secondary">Choose a Domain</h3>
       <div className="flex flex-col gap-1 text-secondary">
-        {identity?.custom_domains.map((domain: CustomDomain) => {
+        {availableDomains.map((domain: CustomDomain) => {
           return (
             <DomainOption
               selectedRoute={selectedRoute}
@@ -139,10 +158,7 @@ const DomainOptions = (props: {
               key={domain.domain}
               domain={domain}
               checked={selectedDomain === domain.domain}
-              setChecked={(d) => {
-                setSelectedDomain(d);
-                setConfirmingReassign(false);
-              }}
+              setChecked={(d) => setSelectedDomain(d)}
               setDomainMenuState={props.setDomainMenuState}
             />
           );
@@ -157,67 +173,38 @@ const DomainOptions = (props: {
         </button>
       </div>
 
-      {confirmingReassign && selectedAssignment && (
-        <div className="text-sm border border-accent-contrast rounded-md p-2 flex flex-col gap-2">
-          <p className="text-secondary">
-            <strong>{selectedDomain}</strong> is currently assigned to{" "}
-            {describeAssignment(selectedAssignment)}. Publishing here will
-            remove that assignment.
-          </p>
-          <div className="flex gap-2 justify-end">
-            <button
-              className="text-accent-contrast text-sm"
-              onMouseDown={() => setConfirmingReassign(false)}
-            >
-              Cancel
-            </button>
-            <ButtonPrimary compact onMouseDown={doPublish}>
-              Reassign & Publish
-            </ButtonPrimary>
-          </div>
-        </div>
-      )}
-
-      {!confirmingReassign && (
-        <div className="flex gap-3 items-center justify-end">
-          {props.domainConnected && (
-            <button
-              onMouseDown={() => {
-                props.setShareMenuState("default");
-                toaster({
-                  content: (
-                    <div className="font-bold">
-                      Unpublished from custom domain!
-                    </div>
-                  ),
-                  type: "error",
-                });
-              }}
-            >
-              Unpublish
-            </button>
-          )}
-
-          <ButtonPrimary
-            id="publish-to-domain"
-            disabled={
-              domains?.[0]
-                ? domains[0].domain === selectedDomain &&
-                  domains[0].route.slice(1) === selectedRoute
-                : !selectedDomain
-            }
-            onClick={async () => {
-              if (willReassign) {
-                setConfirmingReassign(true);
-                return;
-              }
-              await doPublish();
+      <div className="flex gap-3 items-center justify-end">
+        {props.domainConnected && (
+          <button
+            onMouseDown={() => {
+              props.setShareMenuState("default");
+              toaster({
+                content: (
+                  <div className="font-bold">
+                    Unpublished from custom domain!
+                  </div>
+                ),
+                type: "error",
+              });
             }}
           >
-            Publish!
-          </ButtonPrimary>
-        </div>
-      )}
+            Unpublish
+          </button>
+        )}
+
+        <ButtonPrimary
+          id="publish-to-domain"
+          disabled={
+            domains?.[0]
+              ? domains[0].domain === selectedDomain &&
+                domains[0].route.slice(1) === selectedRoute
+              : !selectedDomain
+          }
+          onClick={doPublish}
+        >
+          Publish!
+        </ButtonPrimary>
+      </div>
     </div>
   );
 };
@@ -233,7 +220,6 @@ const DomainOption = (props: {
   let [value, setValue] = useState("");
   let { pending } = useDomainStatus(props.domain.domain);
   let assignment = getDomainAssignment(props.domain);
-  let assignedElsewhere = assignment.type !== "unassigned";
 
   return (
     <label htmlFor={props.domain.domain}>
@@ -258,7 +244,7 @@ const DomainOption = (props: {
             pending
               ? "border-border-light text-secondary justify-between gap-2 items-center "
               : !props.checked
-                ? `flex-wrap border-border-light ${assignedElsewhere ? "opacity-70" : ""}`
+                ? "flex-wrap border-border-light"
                 : "flex-wrap border-accent-1 bg-accent-1 text-accent-2 font-bold"
           } `}
       >
@@ -266,7 +252,7 @@ const DomainOption = (props: {
           <div className={`w-max truncate ${pending && "animate-pulse"}`}>
             {props.domain.domain}
           </div>
-          {!props.checked && assignedElsewhere && !pending && (
+          {!props.checked && assignment.type === "document" && !pending && (
             <span className="text-xs text-tertiary">
               {describeAssignment(assignment)}
             </span>
diff --git a/components/Domains/DomainSettingsView.tsx b/components/Domains/DomainSettingsView.tsx
index 6c5d84d2..aa3d75e8 100644
--- a/components/Domains/DomainSettingsView.tsx
+++ b/components/Domains/DomainSettingsView.tsx
@@ -1,11 +1,15 @@
 "use client";
 import { useState } from "react";
-import { ButtonPrimary } from "components/Buttons";
 import { useDomainStatus } from "./useDomainStatus";
 import { DotLoader } from "components/utils/DotLoader";
 import { deleteDomain } from "actions/domains/deleteDomain";
 import { removeDomainAssignment } from "actions/domains/removeDomainAssignment";
-import { useIdentityData } from "components/IdentityProvider";
+import { removeDomainRoute } from "actions/domains/removeDomainRoute";
+import {
+  useIdentityData,
+  mutateIdentityData,
+} from "components/IdentityProvider";
+import { getDomainAssignment } from "./domainAssignment";
 
 export function DomainSettingsView(props: {
   domain: string;
@@ -13,10 +17,20 @@ export function DomainSettingsView(props: {
   onRemoveAssignment?: () => void;
   onDeleteDomain?: () => void;
 }) {
-  let { data, pending: needsSetup, mutate: mutateDomainStatus } = useDomainStatus(props.domain);
-  let { mutate: mutateIdentity } = useIdentityData();
+  let {
+    data,
+    pending: needsSetup,
+    mutate: mutateDomainStatus,
+  } = useDomainStatus(props.domain);
+  let { identity, mutate: mutateIdentity } = useIdentityData();
   let isSubdomain = props.domain.split(".").length > 2;
 
+  let domainData = identity?.custom_domains.find(
+    (d) => d.domain === props.domain,
+  );
+  let assignment = domainData ? getDomainAssignment(domainData) : null;
+  let isAssigned = assignment && assignment.type !== "unassigned";
+
   return (
     <div className="flex flex-col gap-[6px] text-sm text-primary max-w-full">
       <h3 className="text-secondary">{props.domain}</h3>
@@ -100,6 +114,73 @@ export function DomainSettingsView(props: {
         <div className="text-green-600">This domain is verified!</div>
       )}
 
+      {/* Assignment list */}
+      {props.onRemoveAssignment && isAssigned && domainData && (
+        <div className="flex flex-col gap-1 mt-1">
+          <h4 className="text-tertiary text-xs">Assigned to</h4>
+          {domainData.publication_domains.length > 0 && (
+            <div className="flex items-center justify-between px-[6px] py-1 border rounded-md border-border-light">
+              <span className="text-secondary">publication</span>
+              <button
+                className="text-accent-contrast text-xs"
+                type="button"
+                onMouseDown={async () => {
+                  mutateIdentityData(mutateIdentity, (draft) => {
+                    let domain = draft.custom_domains.find(
+                      (d) => d.domain === props.domain,
+                    );
+                    if (domain) {
+                      domain.publication_domains = [];
+                    }
+                  });
+                  props.onRemoveAssignment?.();
+                  await removeDomainAssignment({ domain: props.domain });
+                }}
+              >
+                remove
+              </button>
+            </div>
+          )}
+          {domainData.custom_domain_routes.map((route) => (
+            <div
+              key={route.id}
+              className="flex items-center justify-between px-[6px] py-1 border rounded-md border-border-light"
+            >
+              <a
+                href={`/${route.edit_permission_token}`}
+                className="text-accent-contrast hover:underline truncate"
+              >
+                {route.route}
+              </a>
+              <button
+                className="text-accent-contrast text-xs shrink-0 ml-2"
+                type="button"
+                onMouseDown={async () => {
+                  mutateIdentityData(mutateIdentity, (draft) => {
+                    let domain = draft.custom_domains.find(
+                      (d) => d.domain === props.domain,
+                    );
+                    if (domain) {
+                      domain.custom_domain_routes =
+                        domain.custom_domain_routes.filter(
+                          (r) => r.id !== route.id,
+                        );
+                    }
+                  });
+                  // If this was the last route, go back to the list
+                  if (domainData.custom_domain_routes.length <= 1) {
+                    props.onRemoveAssignment?.();
+                  }
+                  await removeDomainRoute({ routeId: route.id });
+                }}
+              >
+                remove
+              </button>
+            </div>
+          ))}
+        </div>
+      )}
+
       <div className="flex flex-col gap-2 mt-2">
         <div className="flex gap-3 justify-between items-center">
           <button
@@ -119,27 +200,18 @@ export function DomainSettingsView(props: {
         <hr className="border-border-light" />
 
         <div className="flex gap-3 justify-between items-center">
-          {props.onRemoveAssignment && (
-            <button
-              className="text-accent-contrast text-sm"
-              type="button"
-              onMouseDown={async () => {
-                await removeDomainAssignment({ domain: props.domain });
-                mutateIdentity();
-                props.onRemoveAssignment?.();
-              }}
-            >
-              Remove Assignment
-            </button>
-          )}
           {props.onDeleteDomain && (
             <button
               className="text-accent-contrast font-bold text-sm"
               type="button"
               onMouseDown={async () => {
-                await deleteDomain({ domain: props.domain });
-                mutateIdentity();
+                mutateIdentityData(mutateIdentity, (draft) => {
+                  draft.custom_domains = draft.custom_domains.filter(
+                    (d) => d.domain !== props.domain,
+                  );
+                });
                 props.onDeleteDomain?.();
+                await deleteDomain({ domain: props.domain });
               }}
             >
               Delete Domain
diff --git a/components/Domains/PublicationDomains.tsx b/components/Domains/PublicationDomains.tsx
index 75623f8f..9105703c 100644
--- a/components/Domains/PublicationDomains.tsx
+++ b/components/Domains/PublicationDomains.tsx
@@ -3,7 +3,10 @@ import { useState } from "react";
 import { mutate } from "swr";
 import { useDomainStatus } from "./useDomainStatus";
 import { getDomainAssignment, describeAssignment } from "./domainAssignment";
-import { useIdentityData } from "components/IdentityProvider";
+import {
+  useIdentityData,
+  mutateIdentityData,
+} from "components/IdentityProvider";
 import { ButtonPrimary } from "components/Buttons";
 import {
   usePublicationData,
@@ -194,16 +197,33 @@ function UnassignedDomainRow(props: {
   onSettings: () => void;
 }) {
   let { pending } = useDomainStatus(props.domainData.domain);
+  let { mutate: mutateIdentity } = useIdentityData();
   let assignment = getDomainAssignment(props.domainData);
   let [confirming, setConfirming] = useState(false);
 
   async function doAssign() {
+    mutateIdentityData(mutateIdentity, (draft) => {
+      let domain = draft.custom_domains.find(
+        (d) => d.domain === props.domainData.domain,
+      );
+      if (domain) {
+        domain.custom_domain_routes = [];
+        domain.publication_domains = [
+          {
+            publication: props.publication_uri,
+            domain: props.domainData.domain,
+            identity: "",
+            created_at: new Date().toISOString(),
+          },
+        ];
+      }
+    });
+    setConfirming(false);
+    props.onAssigned();
     await assignDomainToPublication({
       domain: props.domainData.domain,
       publication_uri: props.publication_uri,
     });
-    setConfirming(false);
-    props.onAssigned();
   }
 
   return (
diff --git a/components/Domains/domainAssignment.ts b/components/Domains/domainAssignment.ts
index ee3b11fe..706215e4 100644
--- a/components/Domains/domainAssignment.ts
+++ b/components/Domains/domainAssignment.ts
@@ -21,11 +21,11 @@ export function getDomainAssignment(domain: CustomDomain): DomainAssignment {
 export function describeAssignment(assignment: DomainAssignment): string {
   switch (assignment.type) {
     case "publication":
-      return "a publication";
+      return "publication";
     case "document":
       return assignment.routes.length === 1
-        ? `a leaflet at ${assignment.routes[0]}`
-        : `${assignment.routes.length} leaflets`;
+        ? "1 page"
+        : `${assignment.routes.length} pages`;
     case "unassigned":
       return "";
   }