Edit flow configured

app/(app)/create/hooks/useCreateFlowNavigation.ts

@@ -6,6 +6,8 @@ import { useCreateFlow } from "../context/CreateFlowContext";
 import type { CreateFlowStep } from "../types";
 import {
   type CreateFlowNavigationOptions,
+  type CreateFlowReviewReturnTarget,
+  CREATE_FLOW_REVIEW_RETURN_QUERY_KEY,
   buildTemplateReviewHref,
   getNextStep,
   getPreviousStep,
@@ -46,7 +48,10 @@ export function useCreateFlowNavigation(
   currentStep: CreateFlowStep | null;
   goToNextStep: () => void;
   goToPreviousStep: () => void;
-  goToStep: (_step: CreateFlowStep) => void;
+  goToStep: (
+    _step: CreateFlowStep,
+    _navOpts?: { reviewReturn?: CreateFlowReviewReturnTarget },
+  ) => void;
   canGoNext: () => boolean;
   canGoBack: () => boolean;
   nextStep: CreateFlowStep | null;
@@ -122,11 +127,21 @@ export function useCreateFlowNavigation(
   );
 
   const goToStep = useCallback(
-    (step: CreateFlowStep) => {
+    (
+      step: CreateFlowStep,
+      navOpts?: { reviewReturn?: CreateFlowReviewReturnTarget },
+    ) => {
       blurActiveElement();
-      router.push(`/create/${step}`);
+      const params = new URLSearchParams(searchParams?.toString() ?? "");
+      if (navOpts?.reviewReturn != null) {
+        params.set(CREATE_FLOW_REVIEW_RETURN_QUERY_KEY, navOpts.reviewReturn);
+      } else {
+        params.delete(CREATE_FLOW_REVIEW_RETURN_QUERY_KEY);
+      }
+      const qs = params.toString();
+      router.push(qs.length > 0 ? `/create/${step}?${qs}` : `/create/${step}`);
     },
-    [router],
+    [router, searchParams],
   );
 
   const canGoNext = useCallback(() => nextStep !== null, [nextStep]);

app/(app)/create/hooks/useMethodCardDeckOrdering.ts

@@ -0,0 +1,109 @@
+"use client";
+
+import { useEffect, useMemo } from "react";
+import { useCreateFlow } from "../context/CreateFlowContext";
+import type { CreateFlowMethodCardFacetSection } from "../types";
+import {
+  mergeCompactCardIdsWithPinnedSelected,
+  orderRankedMethodsWithPinnedSelection,
+} from "../../../../lib/create/methodCardDisplayOrder";
+import {
+  deriveCompactCards,
+  rankMethodsByScore,
+  useFacetRecommendations,
+  type RecommendationSection,
+} from "./useFacetRecommendations";
+
+type MethodEntry = { id: string; label: string; supportText: string };
+
+/**
+ * Applies score ranking, compact-slot rules, optional “pinned selection” showcase
+ * order, and clears the pin draft flag when a section loses all selections.
+ */
+export function useMethodCardDeckOrdering(
+  section: RecommendationSection,
+  methods: readonly MethodEntry[],
+  selectedIds: readonly string[],
+) {
+  const { state, setMethodSectionsPinCommitted } = useCreateFlow();
+  const facetKey = section as CreateFlowMethodCardFacetSection;
+  const { scoresBySlug, hasAnyFacets } = useFacetRecommendations(section);
+
+  const pinStored =
+    state.methodSectionsPinCommitted?.[facetKey] === true;
+  const pinActive = Boolean(pinStored && selectedIds.length > 0);
+
+  useEffect(() => {
+    if (selectedIds.length > 0) return;
+    if (!pinStored) return;
+    setMethodSectionsPinCommitted(facetKey, false);
+  }, [
+    facetKey,
+    pinStored,
+    selectedIds.length,
+    setMethodSectionsPinCommitted,
+  ]);
+
+  const rankedMethods = useMemo(
+    () => rankMethodsByScore(methods, scoresBySlug),
+    [methods, scoresBySlug],
+  );
+
+  const displayMethods = useMemo(
+    () =>
+      orderRankedMethodsWithPinnedSelection(
+        rankedMethods,
+        selectedIds,
+        pinActive,
+      ),
+    [rankedMethods, selectedIds, pinActive],
+  );
+
+  const { compactCardIds: baseCompactCardIds, recommendedIds } = useMemo(
+    () =>
+      deriveCompactCards(
+        rankedMethods,
+        scoresBySlug,
+        hasAnyFacets,
+        /* limit */ 5,
+      ),
+    [rankedMethods, scoresBySlug, hasAnyFacets],
+  );
+
+  const compactCardIds = useMemo(
+    () =>
+      mergeCompactCardIdsWithPinnedSelected(
+        displayMethods.map((m) => m.id),
+        baseCompactCardIds,
+        selectedIds,
+        pinActive,
+        5,
+      ),
+    [displayMethods, baseCompactCardIds, selectedIds, pinActive],
+  );
+
+  const sampleCards = useMemo(
+    () =>
+      displayMethods.map((entry) => ({
+        id: entry.id,
+        label: entry.label,
+        supportText: entry.supportText,
+        recommended: recommendedIds.has(entry.id),
+      })),
+    [displayMethods, recommendedIds],
+  );
+
+  const methodById = useMemo(
+    () => new Map(rankedMethods.map((entry) => [entry.id, entry])),
+    [rankedMethods],
+  );
+
+  return {
+    rankedMethods,
+    displayMethods,
+    compactCardIds,
+    recommendedIds,
+    sampleCards,
+    methodById,
+  };
+}