From 1117580f0abaefc76d512f07cff6328655dc3d54 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:31:10 +0300
Subject: [PATCH 01/28] Extract shared zoom, geometry, and minimap utilities
 from workflow editor.

---
 .../Workflow/Editor/AdaptiveGrid.vue          |   3 +-
 .../Workflow/Editor/AreaHighlight.vue         |   2 +-
 .../Workflow/Editor/Comments/FrameComment.vue |   2 +-
 .../Editor/Comments/FreehandComment.vue       |   2 +-
 .../Workflow/Editor/Comments/useResizable.ts  |   3 +-
 .../src/components/Workflow/Editor/Lint.vue   |   1 +
 .../Workflow/Editor/SVGConnection.vue         |   6 +-
 .../Workflow/Editor/Tools/InputCatcher.vue    |   2 +-
 .../Workflow/Editor/Tools/useToolLogic.ts     |  10 +-
 .../Workflow/Editor/WorkflowEdges.vue         |   2 +-
 .../Workflow/Editor/WorkflowGraph.vue         |  10 +-
 .../Workflow/Editor/WorkflowMinimap.vue       | 130 +++++-----------
 .../Workflow/Editor/ZoomControl.vue           |  78 +---------
 .../Editor/composables/workflowBoundingBox.ts |   3 +-
 .../Workflow/Editor/modules/layout.ts         |   3 +-
 .../Workflow/Editor/modules/zoomLevels.ts     |  73 ++-------
 .../Editor => }/composables/d3Zoom.ts         |  10 +-
 .../src/composables/useMinimapInteraction.ts  | 144 ++++++++++++++++++
 .../composables/viewportBoundingBox.ts        |   3 +-
 .../src/stores/workflowEditorCommentStore.ts  |   4 +-
 .../src/stores/workflowEditorToolbarStore.ts  |   2 +-
 client/src/stores/workflowSearchStore.ts      |   2 +-
 client/src/utils/connectionPath.ts            | 127 +++++++++++++++
 .../Editor/modules => utils}/geometry.ts      |   0
 client/src/utils/zoomLevels.ts                |  61 ++++++++
 25 files changed, 419 insertions(+), 264 deletions(-)
 rename client/src/{components/Workflow/Editor => }/composables/d3Zoom.ts (92%)
 create mode 100644 client/src/composables/useMinimapInteraction.ts
 rename client/src/{components/Workflow/Editor => }/composables/viewportBoundingBox.ts (97%)
 create mode 100644 client/src/utils/connectionPath.ts
 rename client/src/{components/Workflow/Editor/modules => utils}/geometry.ts (100%)
 create mode 100644 client/src/utils/zoomLevels.ts

diff --git a/client/src/components/Workflow/Editor/AdaptiveGrid.vue b/client/src/components/Workflow/Editor/AdaptiveGrid.vue
index 580c27d675c..12273682e85 100644
--- a/client/src/components/Workflow/Editor/AdaptiveGrid.vue
+++ b/client/src/components/Workflow/Editor/AdaptiveGrid.vue
@@ -3,8 +3,7 @@ import type { UseElementBoundingReturn } from "@vueuse/core";
 import { computed, onMounted, type Ref, ref, watch } from "vue";
 
 import { useAnimationFrame } from "@/composables/sensors/animationFrame";
-
-import { type AxisAlignedBoundingBox, Transform, type WorkflowTransform } from "./modules/geometry";
+import { type AxisAlignedBoundingBox, Transform, type WorkflowTransform } from "@/utils/geometry";
 
 const lineGap = 10;
 
diff --git a/client/src/components/Workflow/Editor/AreaHighlight.vue b/client/src/components/Workflow/Editor/AreaHighlight.vue
index 2b4163f8ecb..29091bc0cd8 100644
--- a/client/src/components/Workflow/Editor/AreaHighlight.vue
+++ b/client/src/components/Workflow/Editor/AreaHighlight.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { computed, ref } from "vue";
 
-import type { Rectangle } from "@/components/Workflow/Editor/modules/geometry";
+import type { Rectangle } from "@/utils/geometry";
 import { wait } from "@/utils/utils";
 
 const bounds = ref<Rectangle>({ x: 0, y: 0, width: 0, height: 0 });
diff --git a/client/src/components/Workflow/Editor/Comments/FrameComment.vue b/client/src/components/Workflow/Editor/Comments/FrameComment.vue
index 37360dd97db..2b3d38d4a1a 100644
--- a/client/src/components/Workflow/Editor/Comments/FrameComment.vue
+++ b/client/src/components/Workflow/Editor/Comments/FrameComment.vue
@@ -7,10 +7,10 @@ import { BButton, BButtonGroup } from "bootstrap-vue";
 import purify from "dompurify";
 import { computed, onMounted, reactive, ref, watch } from "vue";
 
-import { AxisAlignedBoundingBox, type Rectangle } from "@/components/Workflow/Editor/modules/geometry";
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type { FrameWorkflowComment, WorkflowComment, WorkflowCommentColor } from "@/stores/workflowEditorCommentStore";
 import type { Step } from "@/stores/workflowStepStore";
+import { AxisAlignedBoundingBox, type Rectangle } from "@/utils/geometry";
 
 import { LazyMoveMultipleAction } from "../Actions/workflowActions";
 import { brighterColors, darkenedColors } from "./colors";
diff --git a/client/src/components/Workflow/Editor/Comments/FreehandComment.vue b/client/src/components/Workflow/Editor/Comments/FreehandComment.vue
index 45e44a9dd58..7de1de01807 100644
--- a/client/src/components/Workflow/Editor/Comments/FreehandComment.vue
+++ b/client/src/components/Workflow/Editor/Comments/FreehandComment.vue
@@ -4,8 +4,8 @@ import { computed } from "vue";
 
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type { FreehandWorkflowComment } from "@/stores/workflowEditorCommentStore";
+import { vecSubtract } from "@/utils/geometry";
 
-import { vecSubtract } from "../modules/geometry";
 import { colors } from "./colors";
 
 const props = defineProps<{
diff --git a/client/src/components/Workflow/Editor/Comments/useResizable.ts b/client/src/components/Workflow/Editor/Comments/useResizable.ts
index 61515abdd2d..e1303c5ec51 100644
--- a/client/src/components/Workflow/Editor/Comments/useResizable.ts
+++ b/client/src/components/Workflow/Editor/Comments/useResizable.ts
@@ -2,8 +2,7 @@ import { useEventListener } from "@vueuse/core";
 import { type Ref, watch } from "vue";
 
 import { useWorkflowStores } from "@/composables/workflowStores";
-
-import { vecSnap } from "../modules/geometry";
+import { vecSnap } from "@/utils/geometry";
 
 /**
  * Common functionality required for handling a user resizable element.
diff --git a/client/src/components/Workflow/Editor/Lint.vue b/client/src/components/Workflow/Editor/Lint.vue
index 9ef0a845012..1ff118aabd5 100644
--- a/client/src/components/Workflow/Editor/Lint.vue
+++ b/client/src/components/Workflow/Editor/Lint.vue
@@ -6,6 +6,7 @@ import type { DatatypesMapperModel } from "@/components/Datatypes/model";
 import { type ConfirmDialogOptions, useConfirmDialog } from "@/composables/confirmDialog";
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type { Steps } from "@/stores/workflowStepStore";
+import type { Rectangle } from "@/utils/geometry";
 
 import {
     bestPracticeWarningAnnotation,
diff --git a/client/src/components/Workflow/Editor/SVGConnection.vue b/client/src/components/Workflow/Editor/SVGConnection.vue
index 547ad716312..195516f1edd 100644
--- a/client/src/components/Workflow/Editor/SVGConnection.vue
+++ b/client/src/components/Workflow/Editor/SVGConnection.vue
@@ -1,11 +1,11 @@
 <script setup lang="ts">
-import { curveBasis, line } from "d3";
 import { computed, type PropType } from "vue";
 
 import { useWorkflowStores } from "@/composables/workflowStores";
 import { getConnectionId } from "@/stores/workflowConnectionStore";
 import type { TerminalPosition } from "@/stores/workflowEditorStateStore";
 import type { Connection } from "@/stores/workflowStoreTypes";
+import { curveBasisPath } from "@/utils/connectionPath";
 
 const props = defineProps({
     id: String,
@@ -25,8 +25,6 @@ const props = defineProps({
 
 const ribbonMargin = 4;
 
-const curve = line().curve(curveBasis);
-
 const { connectionStore, stateStore, stepStore } = useWorkflowStores();
 
 const outputPos = computed(() => {
@@ -165,7 +163,7 @@ const paths = computed(() => {
         }
     });
 
-    return lines.map((l) => curve(l)!);
+    return lines.map((l) => curveBasisPath(l));
 });
 
 const lineWidth = computed(() => {
diff --git a/client/src/components/Workflow/Editor/Tools/InputCatcher.vue b/client/src/components/Workflow/Editor/Tools/InputCatcher.vue
index 9fa35e2f802..1cdb7466637 100644
--- a/client/src/components/Workflow/Editor/Tools/InputCatcher.vue
+++ b/client/src/components/Workflow/Editor/Tools/InputCatcher.vue
@@ -2,8 +2,8 @@
 import { useEventListener } from "@vueuse/core";
 import { computed, ref, watch } from "vue";
 
-import { Transform, type WorkflowTransform } from "@/components/Workflow/Editor/modules/geometry";
 import { useWorkflowStores } from "@/composables/workflowStores";
+import { Transform, type WorkflowTransform } from "@/utils/geometry";
 
 const props = defineProps<{
     transform: WorkflowTransform;
diff --git a/client/src/components/Workflow/Editor/Tools/useToolLogic.ts b/client/src/components/Workflow/Editor/Tools/useToolLogic.ts
index 35fdada3893..bb19bb4b22f 100644
--- a/client/src/components/Workflow/Editor/Tools/useToolLogic.ts
+++ b/client/src/components/Workflow/Editor/Tools/useToolLogic.ts
@@ -4,10 +4,6 @@ import { ref, watch } from "vue";
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type { BaseWorkflowComment } from "@/stores/workflowEditorCommentStore";
 import { assertDefined } from "@/utils/assertions";
-import { match } from "@/utils/utils";
-
-import { AddCommentAction } from "../Actions/commentActions";
-import { AddToSelectionAction, RemoveFromSelectionAction } from "../Actions/workflowActions";
 import {
     AxisAlignedBoundingBox,
     vecMax,
@@ -16,7 +12,11 @@ import {
     vecSnap,
     vecSubtract,
     type Vector,
-} from "../modules/geometry";
+} from "@/utils/geometry";
+import { match } from "@/utils/utils";
+
+import { AddCommentAction } from "../Actions/commentActions";
+import { AddToSelectionAction, RemoveFromSelectionAction } from "../Actions/workflowActions";
 
 export function useToolLogic() {
     const comment = ref<BaseWorkflowComment | null>(null);
diff --git a/client/src/components/Workflow/Editor/WorkflowEdges.vue b/client/src/components/Workflow/Editor/WorkflowEdges.vue
index 38f372143c3..189b064bb85 100644
--- a/client/src/components/Workflow/Editor/WorkflowEdges.vue
+++ b/client/src/components/Workflow/Editor/WorkflowEdges.vue
@@ -5,8 +5,8 @@ import { computed, type Ref } from "vue";
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type { TerminalPosition } from "@/stores/workflowEditorStateStore";
 import type { Connection, OutputTerminal } from "@/stores/workflowStoreTypes";
+import type { WorkflowTransform } from "@/utils/geometry";
 
-import type { WorkflowTransform } from "./modules/geometry";
 import type { OutputTerminals } from "./modules/terminals";
 
 import SVGConnection from "./SVGConnection.vue";
diff --git a/client/src/components/Workflow/Editor/WorkflowGraph.vue b/client/src/components/Workflow/Editor/WorkflowGraph.vue
index ccc814d72ac..c4c0b54f76a 100644
--- a/client/src/components/Workflow/Editor/WorkflowGraph.vue
+++ b/client/src/components/Workflow/Editor/WorkflowGraph.vue
@@ -4,16 +4,16 @@ import { storeToRefs } from "pinia";
 import { computed, type PropType, provide, reactive, type Ref, ref, watch, watchEffect } from "vue";
 
 import { DatatypesMapperModel } from "@/components/Datatypes/model";
+import { useD3Zoom } from "@/composables/d3Zoom";
+import { useViewportBoundingBox } from "@/composables/viewportBoundingBox";
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type { TerminalPosition, XYPosition } from "@/stores/workflowEditorStateStore";
 import type { Step } from "@/stores/workflowStepStore";
 import { assertDefined } from "@/utils/assertions";
+import type { Rectangle, Vector } from "@/utils/geometry";
 
-import { useD3Zoom } from "./composables/d3Zoom";
 import { useFocusedNodes } from "./composables/useFocusedNodes";
-import { useViewportBoundingBox } from "./composables/viewportBoundingBox";
 import { useWorkflowBoundingBox } from "./composables/workflowBoundingBox";
-import type { Vector } from "./modules/geometry";
 import type { OutputTerminals } from "./modules/terminals";
 import { maxZoom, minZoom } from "./modules/zoomLevels";
 
@@ -23,11 +23,11 @@ import BoxSelectPreview from "./Tools/BoxSelectPreview.vue";
 import InputCatcher from "./Tools/InputCatcher.vue";
 import ToolBar from "./Tools/ToolBar.vue";
 import LoadingOverlay from "@/components/Common/LoadingOverlay.vue";
+import ZoomControl from "@/components/Graph/ZoomControl.vue";
 import AreaHighlight from "@/components/Workflow/Editor/AreaHighlight.vue";
 import WorkflowNode from "@/components/Workflow/Editor/Node.vue";
 import WorkflowEdges from "@/components/Workflow/Editor/WorkflowEdges.vue";
 import WorkflowMinimap from "@/components/Workflow/Editor/WorkflowMinimap.vue";
-import ZoomControl from "@/components/Workflow/Editor/ZoomControl.vue";
 
 const emit = defineEmits(["transform", "graph-offset", "onRemove", "scrollTo", "stepClicked"]);
 const props = defineProps({
@@ -59,7 +59,7 @@ const {
     setZoom,
     moveTo,
     setTransform: d3SetTransform,
-} = useD3Zoom(scale.value, minZoom, maxZoom, canvas, scroll, props.initialPosition);
+} = useD3Zoom(scale.value, minZoom, maxZoom, canvas, props.initialPosition);
 
 watch(
     () => transform.value,
diff --git a/client/src/components/Workflow/Editor/WorkflowMinimap.vue b/client/src/components/Workflow/Editor/WorkflowMinimap.vue
index 626979d1cf7..e98cc951557 100644
--- a/client/src/components/Workflow/Editor/WorkflowMinimap.vue
+++ b/client/src/components/Workflow/Editor/WorkflowMinimap.vue
@@ -1,10 +1,10 @@
 <script setup lang="ts">
-import { useDraggable, type UseElementBoundingReturn } from "@vueuse/core";
+import type { UseElementBoundingReturn } from "@vueuse/core";
 import type { Ref } from "vue";
 import { computed, nextTick, onMounted, ref, unref, watch } from "vue";
 
 import { useAnimationFrame } from "@/composables/sensors/animationFrame";
-import { useAnimationFrameThrottle } from "@/composables/throttle";
+import { useMinimapInteraction } from "@/composables/useMinimapInteraction";
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type {
     FrameWorkflowComment,
@@ -14,6 +14,7 @@ import type {
     WorkflowComment,
 } from "@/stores/workflowEditorCommentStore";
 import type { Step, Steps } from "@/stores/workflowStepStore";
+import { AxisAlignedBoundingBox } from "@/utils/geometry";
 
 import { useWorkflowBoundingBox } from "./composables/workflowBoundingBox";
 import {
@@ -24,7 +25,6 @@ import {
     getStepColor,
     initStateColors,
 } from "./modules/canvasDraw";
-import { type AxisAlignedBoundingBox, Transform } from "./modules/geometry";
 
 const props = defineProps<{
     steps: Steps;
@@ -45,10 +45,6 @@ const { isJustCreated } = commentStore;
 const canvas: Ref<HTMLCanvasElement | null> = ref(null);
 let redraw = false;
 
-// it is important these throttles are defined before useAnimationFrame,
-// so that they are executed first in the frame loop
-const { throttle: dragThrottle } = useAnimationFrameThrottle();
-
 watch(
     () => props.viewportBoundingBox,
     () => (redraw = true),
@@ -59,20 +55,14 @@ const { getWorkflowBoundingBox } = useWorkflowBoundingBox();
 
 let aabbChanged = false;
 
-/** transform mapping workflow coordinates to minimap coordinates */
-let canvasTransform = new Transform();
+// Workflow-specific: compute padded, squared content bounds
+const workflowContentBounds = ref(new AxisAlignedBoundingBox());
 
 function recalculateAABB() {
     const aabb = getWorkflowBoundingBox();
-
     aabb.squareCenter();
     aabb.expand(120);
-
-    // transform canvas to show entire workflow bounding box
-    if (canvas.value) {
-        const scale = canvas.value.width / aabb.width;
-        canvasTransform = new Transform().translate([-aabb.x * scale, -aabb.y * scale]).scale([scale, scale]);
-    }
+    workflowContentBounds.value = aabb;
 }
 
 // redraw if any steps or comments change
@@ -88,7 +78,6 @@ watch(
 );
 
 // these settings are controlled via css, so they can be defined in one common place
-// this ensures future style changes wont break the minimap's behavior
 const colors = {
     node: "#000",
     error: "#000",
@@ -129,10 +118,42 @@ onMounted(async () => {
     redraw = true;
 });
 
+// ── Shared interaction ──
+
+const minimap: Ref<HTMLElement | null> = ref(null);
+
+const viewportBoundsRef = computed(() => props.viewportBoundingBox);
+const parentRight = computed(() => unref(props.viewportBounds.right));
+const parentBottom = computed(() => unref(props.viewportBounds.bottom));
+
+const { getCanvasTransform, recomputeTransform, minimapSize } = useMinimapInteraction({
+    canvasRef: canvas,
+    containerRef: minimap,
+    parentRight,
+    parentBottom,
+    contentBounds: workflowContentBounds,
+    viewportBounds: viewportBoundsRef,
+    panBy: (delta) => {
+        if (Object.values(props.steps).length > 0) {
+            emit("panBy", delta);
+        }
+    },
+    moveTo: (pos) => {
+        if (Object.values(props.steps).length > 0) {
+            emit("moveTo", pos);
+        }
+    },
+    storageKey: "overview-size",
+    minSize: size.min,
+    maxSize: size.max,
+    defaultSize: size.default,
+});
+
 // for performance reasons, only draw and calculate on animation frames.
 useAnimationFrame(() => {
     if (aabbChanged) {
         recalculateAABB();
+        recomputeTransform();
         aabbChanged = false;
     }
 
@@ -144,6 +165,7 @@ useAnimationFrame(() => {
 
 /** Renders the entire minimap to the canvas */
 function renderMinimap() {
+    const canvasTransform = getCanvasTransform();
     const ctx = canvas.value!.getContext("2d") as CanvasRenderingContext2D;
     ctx.resetTransform();
     ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
@@ -235,80 +257,6 @@ function renderMinimap() {
     ctx.fill();
     ctx.stroke();
 }
-
-// -- Resizing --
-const minimap: Ref<HTMLCanvasElement | null> = ref(null);
-const { position: dragHandlePosition, isDragging: isHandleDragging } = useDraggable(minimap, {
-    preventDefault: true,
-    exact: true,
-});
-const minimapSize = ref(parseInt(localStorage.getItem("overview-size") || size.default.toString()));
-
-watch(dragHandlePosition, () => {
-    // resize
-    minimapSize.value = Math.max(
-        unref(props.viewportBounds.right) - dragHandlePosition.value.x,
-        unref(props.viewportBounds.bottom) - dragHandlePosition.value.y,
-    );
-
-    // clamp
-    minimapSize.value = Math.min(Math.max(minimapSize.value, size.min), size.max);
-});
-
-watch(isHandleDragging, () => {
-    if (!isHandleDragging.value) {
-        localStorage.setItem("overview-size", minimapSize.value.toString());
-    }
-});
-
-// -- Repositioning Viewport --
-
-/** Scaling factor of the canvas element. Draw size in relation to actual size on screen */
-const scaleFactor = computed(() => size.max / minimapSize.value);
-let dragViewport = false;
-
-useDraggable(canvas, {
-    onStart: (_position, event) => {
-        // minimap coordinates to global coordinates
-        const [x, y] = canvasTransform
-            .inverse()
-            .scale([scaleFactor.value, scaleFactor.value])
-            .apply([event.offsetX, event.offsetY]);
-
-        if (props.viewportBoundingBox.isPointInBounds({ x, y })) {
-            dragViewport = true;
-        }
-    },
-    onMove: (_position, event) => {
-        dragThrottle(() => {
-            if (!dragViewport || Object.values(props.steps).length === 0) {
-                return;
-            }
-
-            // minimap coordinates to global coordinates, without translation
-            const [x, y] = canvasTransform
-                .resetTranslation()
-                .inverse()
-                .scale([scaleFactor.value, scaleFactor.value])
-                .apply([-event.movementX, -event.movementY]);
-
-            emit("panBy", { x, y });
-        });
-    },
-    onEnd(_position, event) {
-        // minimap coordinates to global coordinates
-        const [x, y] = canvasTransform
-            .inverse()
-            .scale([scaleFactor.value, scaleFactor.value])
-            .apply([event.offsetX, event.offsetY]);
-
-        if (!dragViewport && Object.values(props.steps).length > 0) {
-            emit("moveTo", { x, y });
-        }
-
-        dragViewport = false;
-    },
-});
 </script>
 
 <template>
diff --git a/client/src/components/Workflow/Editor/ZoomControl.vue b/client/src/components/Workflow/Editor/ZoomControl.vue
index 1d4317015b3..d8bb9db127c 100644
--- a/client/src/components/Workflow/Editor/ZoomControl.vue
+++ b/client/src/components/Workflow/Editor/ZoomControl.vue
@@ -1,76 +1,4 @@
-<script setup lang="ts">
-import BootstrapVue from "bootstrap-vue";
-import Vue, { computed } from "vue";
-
-import { getZoomInLevel, getZoomOutLevel, isMaxZoom, isMinZoom } from "./modules/zoomLevels";
-
-Vue.use(BootstrapVue);
-
-const props = defineProps({
-    zoomLevel: { type: Number, default: 1 },
-});
-
-const emit = defineEmits<{
-    (e: "onZoom", zoom: number): void;
-}>();
-
-const zoomDefault = 1;
-const zoomPercentage = computed(() => Math.round(props.zoomLevel * 100));
-
-function onZoomIn() {
-    emit("onZoom", getZoomInLevel(props.zoomLevel));
-}
-
-function onZoomOut() {
-    emit("onZoom", getZoomOutLevel(props.zoomLevel));
-}
-
-function onZoomReset() {
-    emit("onZoom", zoomDefault);
-}
+<script lang="ts">
+// Re-export from shared location for backward compatibility
+export { default } from "@/components/Graph/ZoomControl.vue";
 </script>
-
-<template>
-    <span class="zoom-control float-right btn-group-horizontal">
-        <b-button
-            :disabled="isMinZoom(props.zoomLevel)"
-            role="button"
-            class="fa fa-minus"
-            title="Zoom Out"
-            size="sm"
-            aria-label="Zoom Out"
-            @click="onZoomOut" />
-        <b-button
-            v-g-tooltip.hover
-            role="button"
-            class="zoom-reset"
-            variant="light"
-            title="Reset Zoom Level"
-            size="sm"
-            aria-label="Reset Zoom Level"
-            @click="onZoomReset">
-            {{ zoomPercentage }}%
-        </b-button>
-        <b-button
-            :disabled="isMaxZoom(props.zoomLevel)"
-            role="button"
-            class="fa fa-plus"
-            title="Zoom In"
-            size="sm"
-            aria-label="Zoom In"
-            @click="onZoomIn" />
-    </span>
-</template>
-
-<style scoped>
-.zoom-reset {
-    width: 4rem;
-}
-.zoom-control {
-    position: absolute;
-    left: 1rem;
-    bottom: 1rem;
-    cursor: pointer;
-    z-index: 2000;
-}
-</style>
diff --git a/client/src/components/Workflow/Editor/composables/workflowBoundingBox.ts b/client/src/components/Workflow/Editor/composables/workflowBoundingBox.ts
index 6fb99f10d88..114a092130e 100644
--- a/client/src/components/Workflow/Editor/composables/workflowBoundingBox.ts
+++ b/client/src/components/Workflow/Editor/composables/workflowBoundingBox.ts
@@ -1,6 +1,5 @@
 import { useWorkflowStores } from "@/composables/workflowStores";
-
-import { AxisAlignedBoundingBox, type WorkflowTransform } from "../modules/geometry";
+import { AxisAlignedBoundingBox, type WorkflowTransform } from "@/utils/geometry";
 
 export interface BoundingBoxBounds {
     minX: number;
diff --git a/client/src/components/Workflow/Editor/modules/layout.ts b/client/src/components/Workflow/Editor/modules/layout.ts
index 3a7dc279e9c..8d0f3410463 100644
--- a/client/src/components/Workflow/Editor/modules/layout.ts
+++ b/client/src/components/Workflow/Editor/modules/layout.ts
@@ -10,10 +10,9 @@ import {
     type WorkflowStepStore,
 } from "@/stores/workflowStepStore";
 import { assertDefined } from "@/utils/assertions";
+import { AxisAlignedBoundingBox, type Rectangle, rectDistance } from "@/utils/geometry";
 import { match } from "@/utils/utils";
 
-import { AxisAlignedBoundingBox, type Rectangle, rectDistance } from "./geometry";
-
 const elk = new ELK();
 
 export const AUTO_LAYOUT_ORPHAN_EDGE_WARNING_PREFIX = "Auto Layout: skipping edge";
diff --git a/client/src/components/Workflow/Editor/modules/zoomLevels.ts b/client/src/components/Workflow/Editor/modules/zoomLevels.ts
index 234c2456ee1..b3cae92dd94 100644
--- a/client/src/components/Workflow/Editor/modules/zoomLevels.ts
+++ b/client/src/components/Workflow/Editor/modules/zoomLevels.ts
@@ -1,61 +1,12 @@
-import type { Last } from "types/utilityTypes";
-
-export const zoomLevels = [
-    0.1, 0.2, 0.25, 0.33, 0.5, 0.67, 0.75, 0.8, 0.9, 1, 1.1, 1.25, 1.33, 1.5, 2, 2.5, 3, 4, 5,
-] as const;
-
-export type ZoomLevel = (typeof zoomLevels)[number];
-
-export const minZoom = zoomLevels[0];
-export const maxZoom = zoomLevels[zoomLevels.length - 1] as Last<typeof zoomLevels>;
-
-/**
- * Finds the closest snapped zoom level
- * @param zoom decimal number indicating current zoom multiplier
- * @returns snapped zoom level
- */
-export function getSnappedZoom(zoom: number): ZoomLevel {
-    return zoomLevels.reduce((a, b) => {
-        return Math.abs(b - zoom) < Math.abs(a - zoom) ? b : a;
-    });
-}
-
-/**
- * Gets the next largest zoom level
- * @param zoom decimal number indicating current zoom multiplier
- * @returns snapped zoom level
- */
-export function getZoomInLevel(zoom: number): ZoomLevel {
-    const snapped = getSnappedZoom(zoom);
-    const index = zoomLevels.indexOf(snapped);
-
-    if (index === zoomLevels.length - 1) {
-        return snapped;
-    } else {
-        return zoomLevels[index + 1] as ZoomLevel;
-    }
-}
-
-/**
- * Get the next smaller zoom level
- * @param zoom decimal number indicating current zoom multiplier
- * @returns snapped zoom level
- */
-export function getZoomOutLevel(zoom: number): ZoomLevel {
-    const snapped = getSnappedZoom(zoom);
-    const index = zoomLevels.indexOf(snapped);
-
-    if (index === 0) {
-        return snapped;
-    } else {
-        return zoomLevels[index - 1] as ZoomLevel;
-    }
-}
-
-export function isMinZoom(zoom: number): boolean {
-    return zoom === minZoom;
-}
-
-export function isMaxZoom(zoom: number): boolean {
-    return zoom === maxZoom;
-}
+// Re-export from shared location
+export type { ZoomLevel } from "@/utils/zoomLevels";
+export {
+    getSnappedZoom,
+    getZoomInLevel,
+    getZoomOutLevel,
+    isMaxZoom,
+    isMinZoom,
+    maxZoom,
+    minZoom,
+    zoomLevels,
+} from "@/utils/zoomLevels";
diff --git a/client/src/components/Workflow/Editor/composables/d3Zoom.ts b/client/src/composables/d3Zoom.ts
similarity index 92%
rename from client/src/components/Workflow/Editor/composables/d3Zoom.ts
rename to client/src/composables/d3Zoom.ts
index cc211aaab91..94e8998bcf0 100644
--- a/client/src/components/Workflow/Editor/composables/d3Zoom.ts
+++ b/client/src/composables/d3Zoom.ts
@@ -1,10 +1,13 @@
-import type { UseScrollReturn } from "@vueuse/core";
 import { select } from "d3-selection";
 import { type D3ZoomEvent, zoom, zoomIdentity } from "d3-zoom";
 import { type Ref, ref, watch } from "vue";
 
-import type { Vector, WorkflowTransform } from "@/components/Workflow/Editor/modules/geometry";
-import type { XYPosition } from "@/stores/workflowEditorStateStore";
+import type { Vector, WorkflowTransform } from "@/utils/geometry";
+
+export interface XYPosition {
+    x: number;
+    y: number;
+}
 
 // if element is draggable it may implement its own drag handler,
 // but d3zoom would call preventDefault
@@ -31,7 +34,6 @@ export function useD3Zoom(
     minZoom: number,
     maxZoom: number,
     targetRef: Ref<HTMLElement | null>,
-    scroll: UseScrollReturn,
     initialPan: XYPosition = { x: 0, y: 0 },
 ) {
     const transform = ref<WorkflowTransform>({ x: initialPan.x, y: initialPan.y, k: k });
diff --git a/client/src/composables/useMinimapInteraction.ts b/client/src/composables/useMinimapInteraction.ts
new file mode 100644
index 00000000000..b434223d35d
--- /dev/null
+++ b/client/src/composables/useMinimapInteraction.ts
@@ -0,0 +1,144 @@
+import { useDraggable } from "@vueuse/core";
+import { computed, type Ref, ref, unref, watch } from "vue";
+
+import { useAnimationFrameThrottle } from "@/composables/throttle";
+import { type AxisAlignedBoundingBox, Transform } from "@/utils/geometry";
+
+export interface MinimapInteractionOptions {
+    /** Canvas element for pointer interaction */
+    canvasRef: Ref<HTMLCanvasElement | null>;
+    /** Container element for resize dragging */
+    containerRef: Ref<HTMLElement | null>;
+    /** Reactive right/bottom edges of the parent element (for resize computation) */
+    parentRight: Ref<number>;
+    parentBottom: Ref<number>;
+    /** Final content bounding box (consumer owns padding/squaring policy) */
+    contentBounds: Ref<AxisAlignedBoundingBox>;
+    /** Viewport bounding box in content coordinates */
+    viewportBounds: Ref<AxisAlignedBoundingBox>;
+    /** Called with content-coordinate delta when user drags the viewport */
+    panBy: (delta: { x: number; y: number }) => void;
+    /** Called with content-coordinate position when user clicks outside viewport */
+    moveTo: (pos: { x: number; y: number }) => void;
+    /** localStorage key for resize persistence */
+    storageKey: string;
+    /** Minimum minimap display size in pixels */
+    minSize: number;
+    /** Maximum minimap display size in pixels (also used as canvas internal resolution) */
+    maxSize: number;
+    /** Default minimap display size in pixels */
+    defaultSize: number;
+}
+
+export function useMinimapInteraction(options: MinimapInteractionOptions) {
+    const {
+        canvasRef,
+        containerRef,
+        parentRight,
+        parentBottom,
+        contentBounds,
+        viewportBounds,
+        panBy,
+        moveTo,
+        storageKey,
+        minSize,
+        maxSize,
+        defaultSize,
+    } = options;
+
+    // ── Transform: content coordinates → minimap canvas pixels ──
+
+    let canvasTransform = new Transform();
+
+    function recomputeTransform() {
+        const canvas = unref(canvasRef);
+        const bounds = unref(contentBounds);
+        if (!canvas || bounds.width === 0 || bounds.height === 0) {
+            canvasTransform = new Transform();
+            return;
+        }
+        const scaleX = canvas.width / bounds.width;
+        const scaleY = canvas.height / bounds.height;
+        const s = Math.min(scaleX, scaleY);
+        canvasTransform = new Transform().translate([-bounds.x * s, -bounds.y * s]).scale([s, s]);
+    }
+
+    watch(contentBounds, recomputeTransform, { deep: true });
+
+    function getCanvasTransform(): Transform {
+        return canvasTransform;
+    }
+
+    // ── Resize ──
+
+    const minimapSize = ref(parseInt(localStorage.getItem(storageKey) || defaultSize.toString()));
+
+    const { position: dragHandlePosition, isDragging: isHandleDragging } = useDraggable(containerRef, {
+        preventDefault: true,
+        exact: true,
+    });
+
+    const scaleFactor = computed(() => maxSize / minimapSize.value);
+
+    watch(dragHandlePosition, () => {
+        const newSize = Math.max(
+            unref(parentRight) - dragHandlePosition.value.x,
+            unref(parentBottom) - dragHandlePosition.value.y,
+        );
+        minimapSize.value = Math.min(Math.max(newSize, minSize), maxSize);
+    });
+
+    watch(isHandleDragging, () => {
+        if (!isHandleDragging.value) {
+            localStorage.setItem(storageKey, minimapSize.value.toString());
+        }
+    });
+
+    // ── Pointer interaction: click-to-center / drag-to-pan ──
+
+    const { throttle: dragThrottle } = useAnimationFrameThrottle();
+    let dragViewport = false;
+
+    function minimapToContent(offsetX: number, offsetY: number): [number, number] {
+        return canvasTransform.inverse().scale([scaleFactor.value, scaleFactor.value]).apply([offsetX, offsetY]);
+    }
+
+    function minimapDeltaToContent(movementX: number, movementY: number): [number, number] {
+        return canvasTransform
+            .resetTranslation()
+            .inverse()
+            .scale([scaleFactor.value, scaleFactor.value])
+            .apply([-movementX, -movementY]);
+    }
+
+    useDraggable(canvasRef, {
+        onStart: (_position, event) => {
+            const [x, y] = minimapToContent(event.offsetX, event.offsetY);
+            if (unref(viewportBounds).isPointInBounds({ x, y })) {
+                dragViewport = true;
+            }
+        },
+        onMove: (_position, event) => {
+            dragThrottle(() => {
+                if (!dragViewport) {
+                    return;
+                }
+                const [x, y] = minimapDeltaToContent(event.movementX, event.movementY);
+                panBy({ x, y });
+            });
+        },
+        onEnd: (_position, event) => {
+            if (!dragViewport) {
+                const [x, y] = minimapToContent(event.offsetX, event.offsetY);
+                moveTo({ x, y });
+            }
+            dragViewport = false;
+        },
+    });
+
+    return {
+        getCanvasTransform,
+        recomputeTransform,
+        minimapSize,
+    };
+}
diff --git a/client/src/components/Workflow/Editor/composables/viewportBoundingBox.ts b/client/src/composables/viewportBoundingBox.ts
similarity index 97%
rename from client/src/components/Workflow/Editor/composables/viewportBoundingBox.ts
rename to client/src/composables/viewportBoundingBox.ts
index 7755723fdaa..c3ddeca9b2b 100644
--- a/client/src/components/Workflow/Editor/composables/viewportBoundingBox.ts
+++ b/client/src/composables/viewportBoundingBox.ts
@@ -2,8 +2,7 @@ import type { UseElementBoundingReturn } from "@vueuse/core";
 import { type Ref, ref, unref, watch } from "vue";
 
 import { useAnimationFrameThrottle } from "@/composables/throttle";
-
-import { AxisAlignedBoundingBox } from "../modules/geometry";
+import { AxisAlignedBoundingBox } from "@/utils/geometry";
 
 /**
  * Constructs a bounding box following the editors pan and zoom in
diff --git a/client/src/stores/workflowEditorCommentStore.ts b/client/src/stores/workflowEditorCommentStore.ts
index 8c1453dac0e..f76af306e9f 100644
--- a/client/src/stores/workflowEditorCommentStore.ts
+++ b/client/src/stores/workflowEditorCommentStore.ts
@@ -1,6 +1,7 @@
 import { computed, del, ref, set } from "vue";
 
 import type { Color } from "@/components/Workflow/Editor/Comments/colors";
+import { assertDefined } from "@/utils/assertions";
 import {
     AxisAlignedBoundingBox,
     type Rectangle,
@@ -10,8 +11,7 @@ import {
     vecReduceFigures,
     vecSubtract,
     type Vector,
-} from "@/components/Workflow/Editor/modules/geometry";
-import { assertDefined } from "@/utils/assertions";
+} from "@/utils/geometry";
 import { hasKeys, match } from "@/utils/utils";
 
 import { defineScopedStore } from "./scopedStore";
diff --git a/client/src/stores/workflowEditorToolbarStore.ts b/client/src/stores/workflowEditorToolbarStore.ts
index 0db46294287..53be78c055d 100644
--- a/client/src/stores/workflowEditorToolbarStore.ts
+++ b/client/src/stores/workflowEditorToolbarStore.ts
@@ -1,8 +1,8 @@
 import { computed, getCurrentScope, onScopeDispose, reactive, ref, watch } from "vue";
 
-import type { Rectangle } from "@/components/Workflow/Editor/modules/geometry";
 import { useMagicKeys } from "@/composables/useMagicKeys";
 import { useUserLocalStorage } from "@/composables/userLocalStorage";
+import type { Rectangle } from "@/utils/geometry";
 
 import { defineScopedStore } from "./scopedStore";
 import type { WorkflowCommentColor } from "./workflowEditorCommentStore";
diff --git a/client/src/stores/workflowSearchStore.ts b/client/src/stores/workflowSearchStore.ts
index 9ad9e71e5d3..362be574920 100644
--- a/client/src/stores/workflowSearchStore.ts
+++ b/client/src/stores/workflowSearchStore.ts
@@ -1,6 +1,5 @@
 import { ref } from "vue";
 
-import { type Rectangle, Transform } from "@/components/Workflow/Editor/modules/geometry";
 import { defineScopedStore } from "@/stores/scopedStore";
 import { useUndoRedoStore } from "@/stores/undoRedoStore";
 import {
@@ -17,6 +16,7 @@ import {
     useWorkflowStepStore,
 } from "@/stores/workflowStepStore";
 import { assertDefined } from "@/utils/assertions";
+import { type Rectangle, Transform } from "@/utils/geometry";
 
 export type SearchData =
     | {
diff --git a/client/src/utils/connectionPath.ts b/client/src/utils/connectionPath.ts
new file mode 100644
index 00000000000..0203e114ccc
--- /dev/null
+++ b/client/src/utils/connectionPath.ts
@@ -0,0 +1,127 @@
+/**
+ * Shared SVG path generation utilities for graph edge rendering.
+ *
+ * Two rendering strategies:
+ * - curveBasisPath: smooth bezier curves via d3 curveBasis (used by workflow editor)
+ * - orthogonalPath: straight segments with arc-rounded bends (used for ELK-routed graphs)
+ *
+ * Both accept point arrays and return SVG path `d` attribute strings.
+ */
+
+import { curveBasis, line } from "d3";
+
+/** Point with x/y coordinates */
+export interface PathPoint {
+    x: number;
+    y: number;
+}
+
+// ── curveBasis rendering ──
+
+const _curveBasisLine = line().curve(curveBasis);
+
+/**
+ * Render points as a smooth bezier curve using d3's curveBasis interpolation.
+ * Used by the workflow editor for connections between nodes.
+ */
+export function curveBasisPath(points: [number, number][]): string {
+    return _curveBasisLine(points) ?? "";
+}
+
+// ── Orthogonal rendering with arc bends ──
+
+const DEFAULT_RADIUS = 8;
+
+/**
+ * Render orthogonal edge points as an SVG path with rounded corners.
+ * Uses arc segments at each bend point to produce smooth turns while
+ * faithfully following the layout engine's routing.
+ *
+ * Used for ELK-routed graph edges where points form orthogonal paths.
+ */
+export function orthogonalPath(points: PathPoint[], radius: number = DEFAULT_RADIUS): string {
+    if (points.length < 2) {
+        return "";
+    }
+    if (points.length === 2) {
+        return `M ${points[0]!.x} ${points[0]!.y} L ${points[1]!.x} ${points[1]!.y}`;
+    }
+
+    const parts: string[] = [`M ${points[0]!.x} ${points[0]!.y}`];
+
+    for (let i = 1; i < points.length - 1; i++) {
+        const prev = points[i - 1]!;
+        const curr = points[i]!;
+        const next = points[i + 1]!;
+
+        const dx1 = prev.x - curr.x;
+        const dy1 = prev.y - curr.y;
+        const dx2 = next.x - curr.x;
+        const dy2 = next.y - curr.y;
+
+        const d1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+        const d2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+
+        const r = Math.min(radius, d1 / 2, d2 / 2);
+
+        const startX = curr.x + (dx1 / d1) * r;
+        const startY = curr.y + (dy1 / d1) * r;
+        const endX = curr.x + (dx2 / d2) * r;
+        const endY = curr.y + (dy2 / d2) * r;
+
+        const cross = dx1 * dy2 - dy1 * dx2;
+        const sweep = cross > 0 ? 0 : 1;
+
+        parts.push(`L ${startX} ${startY}`);
+        parts.push(`A ${r} ${r} 0 0 ${sweep} ${endX} ${endY}`);
+    }
+
+    const last = points[points.length - 1]!;
+    parts.push(`L ${last.x} ${last.y}`);
+
+    return parts.join(" ");
+}
+
+// ── Control point computation ──
+
+const BASE_LINE_SHIFT = 15;
+const LINE_SHIFT_GROW_X = 0.15;
+const LINE_SHIFT_GROW_Y = 0.08;
+
+/**
+ * Compute bezier control points for a connection between two endpoints.
+ * Uses the same algorithm as the Galaxy workflow editor (SVGConnection.vue):
+ * forward connections get 4 control points, backward connections get 6
+ * for smoother curves.
+ */
+export function computeControlPoints(startX: number, startY: number, endX: number, endY: number): [number, number][] {
+    const forward = endX >= startX;
+    const distX = Math.abs(endX - startX - BASE_LINE_SHIFT);
+    const distY = Math.abs(endY - startY);
+
+    let shiftX: number;
+    if (forward) {
+        shiftX = BASE_LINE_SHIFT + distX * LINE_SHIFT_GROW_X + distY * LINE_SHIFT_GROW_Y;
+    } else {
+        shiftX = BASE_LINE_SHIFT * 2 + distX * LINE_SHIFT_GROW_X * 0.5 + distY * LINE_SHIFT_GROW_Y * 0.5;
+    }
+
+    if (forward) {
+        return [
+            [startX, startY],
+            [startX + shiftX, startY],
+            [endX - shiftX, endY],
+            [endX, endY],
+        ];
+    } else {
+        const shiftY = (endY - startY) / 2;
+        return [
+            [startX, startY],
+            [startX + shiftX, startY],
+            [startX + shiftX, startY + shiftY],
+            [endX - shiftX, endY - shiftY],
+            [endX - shiftX, endY],
+            [endX, endY],
+        ];
+    }
+}
diff --git a/client/src/components/Workflow/Editor/modules/geometry.ts b/client/src/utils/geometry.ts
similarity index 100%
rename from client/src/components/Workflow/Editor/modules/geometry.ts
rename to client/src/utils/geometry.ts
diff --git a/client/src/utils/zoomLevels.ts b/client/src/utils/zoomLevels.ts
new file mode 100644
index 00000000000..234c2456ee1
--- /dev/null
+++ b/client/src/utils/zoomLevels.ts
@@ -0,0 +1,61 @@
+import type { Last } from "types/utilityTypes";
+
+export const zoomLevels = [
+    0.1, 0.2, 0.25, 0.33, 0.5, 0.67, 0.75, 0.8, 0.9, 1, 1.1, 1.25, 1.33, 1.5, 2, 2.5, 3, 4, 5,
+] as const;
+
+export type ZoomLevel = (typeof zoomLevels)[number];
+
+export const minZoom = zoomLevels[0];
+export const maxZoom = zoomLevels[zoomLevels.length - 1] as Last<typeof zoomLevels>;
+
+/**
+ * Finds the closest snapped zoom level
+ * @param zoom decimal number indicating current zoom multiplier
+ * @returns snapped zoom level
+ */
+export function getSnappedZoom(zoom: number): ZoomLevel {
+    return zoomLevels.reduce((a, b) => {
+        return Math.abs(b - zoom) < Math.abs(a - zoom) ? b : a;
+    });
+}
+
+/**
+ * Gets the next largest zoom level
+ * @param zoom decimal number indicating current zoom multiplier
+ * @returns snapped zoom level
+ */
+export function getZoomInLevel(zoom: number): ZoomLevel {
+    const snapped = getSnappedZoom(zoom);
+    const index = zoomLevels.indexOf(snapped);
+
+    if (index === zoomLevels.length - 1) {
+        return snapped;
+    } else {
+        return zoomLevels[index + 1] as ZoomLevel;
+    }
+}
+
+/**
+ * Get the next smaller zoom level
+ * @param zoom decimal number indicating current zoom multiplier
+ * @returns snapped zoom level
+ */
+export function getZoomOutLevel(zoom: number): ZoomLevel {
+    const snapped = getSnappedZoom(zoom);
+    const index = zoomLevels.indexOf(snapped);
+
+    if (index === 0) {
+        return snapped;
+    } else {
+        return zoomLevels[index - 1] as ZoomLevel;
+    }
+}
+
+export function isMinZoom(zoom: number): boolean {
+    return zoom === minZoom;
+}
+
+export function isMaxZoom(zoom: number): boolean {
+    return zoom === maxZoom;
+}

From d84137858864861245732dc72cf8184d2300d601 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:31:13 +0300
Subject: [PATCH 02/28] Add history graph builder manager and pydantic schema.

---
 lib/galaxy/managers/history_graph.py | 576 +++++++++++++++++++++++++++
 lib/galaxy/schema/history_graph.py   |  40 ++
 2 files changed, 616 insertions(+)
 create mode 100644 lib/galaxy/managers/history_graph.py
 create mode 100644 lib/galaxy/schema/history_graph.py

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
new file mode 100644
index 00000000000..45f3c12c709
--- /dev/null
+++ b/lib/galaxy/managers/history_graph.py
@@ -0,0 +1,576 @@
+"""Bounded user-action provenance graph for Galaxy histories.
+
+For each selected top-level history item, resolves its producing
+tool_request and that tool_request's declared inputs from the
+submission payload.  One hop only.  No consumers.  No transitive
+traversal.
+
+See ``~/claude/history_graph/reduced_provenance_model.md``.
+"""
+
+import json
+import logging
+from typing import Optional
+
+from sqlalchemy import (
+    select,
+    union_all,
+)
+from sqlalchemy.orm import Session
+from sqlalchemy.sql.expression import literal_column
+
+from galaxy.model import (
+    Dataset,
+    DatasetCollection,
+    DatasetCollectionElement,
+    HistoryDatasetAssociation,
+    HistoryDatasetCollectionAssociation,
+    Job,
+    JobToOutputDatasetAssociation,
+    JobToOutputDatasetCollectionAssociation,
+    ToolRequest,
+)
+from galaxy.schema.history_graph import (
+    GraphEdge,
+    GraphNode,
+    HistoryGraphResponse,
+    TruncationInfo,
+)
+from galaxy.security.idencoding import IdEncodingHelper
+
+log = logging.getLogger(__name__)
+
+TYPE_RANK = {"dataset": 0, "collection": 1, "tool_request": 2}
+EDGE_TYPE_RANK = {"dataset_input": 0, "dataset_output": 1, "collection_input": 2, "collection_output": 3}
+NODE_TYPE_PREFIX = {"dataset": "d", "collection": "c", "tool_request": "r"}
+CHUNK = 1000
+
+
+class HistoryGraphBuilder:
+    """Builds a bounded provenance graph from selected history items.
+
+    Invariants enforced in code:
+    - HDA producer: JTODA only.  No Dataset.job_id fallback.
+    - HDCA producer: JODCA only.  No TRICA.  No HDCA.job_id.
+    - Inputs: tool_request.request payload only.  No job association tables.
+    - One hop.  No consumers.  No sibling outputs.  No transitive traversal.
+    - Ambiguity (≥2 distinct tool_request_ids): skip, log debug.
+    - Missing producer: no edge.
+    - Malformed payload: skip inputs.
+    """
+
+    def __init__(
+        self,
+        sa_session: Session,
+        security: IdEncodingHelper,
+        history_id: int,
+        limit: int = 500,
+        toolbox=None,
+        include_deleted: bool = False,
+        seed: Optional[str] = None,
+        direction: str = "both",
+        depth: int = 5,
+        older_than_hid: Optional[int] = None,
+        newer_than_hid: Optional[int] = None,
+        seed_scope: Optional[str] = None,
+    ):
+        self.sa_session = sa_session
+        self.security = security
+        self.history_id = history_id
+        self.limit = limit
+        self.toolbox = toolbox
+        self.include_deleted = include_deleted
+        self.seed = seed
+        self.direction = direction
+        self.depth = depth
+        self.older_than_hid = older_than_hid
+        self.newer_than_hid = newer_than_hid
+        self.seed_scope = seed_scope
+        self._sort_keys: dict[str, tuple[int, int]] = {}
+
+    def build(self) -> HistoryGraphResponse:
+        truncation = TruncationInfo()
+        if self.seed_scope:
+            truncation.scope_type = "seed_centered"
+            self._resolve_seed_scope()
+        elif self.older_than_hid is not None or self.newer_than_hid is not None:
+            truncation.scope_type = "window"
+
+        # 1. Select top-level items in scope.
+        dataset_ids, collection_ids, item_capped, oldest_hid, newest_hid = self._select_items()
+        truncation.item_count_capped = item_capped
+        truncation.oldest_hid_included = oldest_hid
+        truncation.newest_hid_included = newest_hid
+
+        # 2. Remove hidden collection elements.
+        dataset_ids = self._remove_hidden_elements(dataset_ids)
+
+        # 3. Producer lookup + payload input resolution.
+        edges: list[GraphEdge] = []
+        tr_nodes: dict[int, Optional[str]] = {}  # tr_id -> tool_id
+        closure_dataset_ids: set[int] = set()
+        closure_collection_ids: set[int] = set()
+
+        hda_producers = self._hda_producers(dataset_ids)
+        hdca_producers = self._hdca_producers(collection_ids)
+        all_producers = {**hda_producers, **hdca_producers}
+
+        # Emit output edges and collect tr_ids.
+        seen_edges: set[tuple[str, str, str]] = set()
+        for item_key, (tr_id, tool_id) in all_producers.items():
+            item_type, item_id = item_key
+            tr_nodes[tr_id] = tool_id
+            src = self._encode("tool_request", tr_id)
+            tgt = self._encode(item_type, item_id)
+            etype = "dataset_output" if item_type == "dataset" else "collection_output"
+            edge_key = (src, tgt, etype)
+            if edge_key not in seen_edges:
+                seen_edges.add(edge_key)
+                edges.append(GraphEdge(source=src, target=tgt, type=etype))
+
+        # Batch-fetch all payloads, parse inputs, emit input edges.
+        payloads = self._fetch_payloads(set(tr_nodes.keys()))
+        for tr_id, payload in payloads.items():
+            input_refs = self._extract_inputs(payload)
+            for ref_type, ref_id in input_refs:
+                src = self._encode(ref_type, ref_id)
+                tgt = self._encode("tool_request", tr_id)
+                etype = "dataset_input" if ref_type == "dataset" else "collection_input"
+                edge_key = (src, tgt, etype)
+                if edge_key not in seen_edges:
+                    seen_edges.add(edge_key)
+                    edges.append(GraphEdge(source=src, target=tgt, type=etype))
+                if ref_type == "dataset" and ref_id not in dataset_ids:
+                    closure_dataset_ids.add(ref_id)
+                elif ref_type == "collection" and ref_id not in collection_ids:
+                    closure_collection_ids.add(ref_id)
+
+        # 4. Filter closure items by the same deleted policy as seed selection.
+        if not self.include_deleted and (closure_dataset_ids or closure_collection_ids):
+            closure_dataset_ids = self._filter_deleted_hdas(closure_dataset_ids)
+            closure_collection_ids = self._filter_deleted_hdcas(closure_collection_ids)
+
+        # Build nodes.
+        all_dataset_ids = dataset_ids | closure_dataset_ids
+        all_collection_ids = collection_ids | closure_collection_ids
+        nodes: list[GraphNode] = []
+        nodes.extend(self._dataset_nodes(all_dataset_ids))
+        nodes.extend(self._collection_nodes(all_collection_ids))
+        nodes.extend(self._tr_nodes(tr_nodes))
+
+        # 5. Resolve tool names.
+        if self.toolbox:
+            self._resolve_tool_names(nodes)
+
+        # 6. Optional seed subgraph filter (in-memory only).
+        if self.seed:
+            node_ids = {n.id for n in nodes}
+            truncation.seed_in_scope = self.seed in node_ids
+            nodes, edges = self._seed_filter(nodes, edges)
+
+        # 7. Sort.
+        nodes, edges = self._sort(nodes, edges)
+        return HistoryGraphResponse(nodes=nodes, edges=edges, truncated=truncation)
+
+    # ── Item selection ──
+
+    def _resolve_seed_scope(self):
+        from galaxy.exceptions import RequestParameterInvalidException
+
+        if not self.seed_scope or len(self.seed_scope) < 2:
+            raise RequestParameterInvalidException(f"Invalid seed_scope: {self.seed_scope!r}")
+        prefix = self.seed_scope[0]
+        if prefix not in ("d", "c"):
+            raise RequestParameterInvalidException(f"Invalid seed_scope prefix: {prefix!r}")
+        try:
+            db_id = self.security.decode_id(self.seed_scope[1:])
+        except Exception:
+            raise RequestParameterInvalidException(f"Invalid seed_scope encoding: {self.seed_scope!r}")
+        model = HistoryDatasetAssociation if prefix == "d" else HistoryDatasetCollectionAssociation
+        row = self.sa_session.execute(
+            select(model.hid).where(model.id == db_id, model.history_id == self.history_id)
+        ).first()
+        if row is None or row.hid is None:
+            raise RequestParameterInvalidException(f"seed_scope {self.seed_scope} not found in history.")
+        half = self.limit // 2
+        self.older_than_hid = row.hid + half + (self.limit % 2)
+        self.newer_than_hid = row.hid - half - 1
+
+    def _select_items(self) -> tuple[set[int], set[int], bool, Optional[int], Optional[int]]:
+        hda_q = select(
+            HistoryDatasetAssociation.id,
+            HistoryDatasetAssociation.hid,
+            literal_column("'dataset'").label("item_type"),
+        ).where(HistoryDatasetAssociation.history_id == self.history_id)
+        if not self.include_deleted:
+            hda_q = hda_q.where(HistoryDatasetAssociation.deleted == False)  # noqa: E712
+        if self.older_than_hid is not None:
+            hda_q = hda_q.where(HistoryDatasetAssociation.hid < self.older_than_hid)
+        if self.newer_than_hid is not None:
+            hda_q = hda_q.where(HistoryDatasetAssociation.hid > self.newer_than_hid)
+
+        hdca_q = select(
+            HistoryDatasetCollectionAssociation.id,
+            HistoryDatasetCollectionAssociation.hid,
+            literal_column("'collection'").label("item_type"),
+        ).where(HistoryDatasetCollectionAssociation.history_id == self.history_id)
+        if not self.include_deleted:
+            hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.deleted == False)  # noqa: E712
+        if self.older_than_hid is not None:
+            hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.hid < self.older_than_hid)
+        if self.newer_than_hid is not None:
+            hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.hid > self.newer_than_hid)
+
+        combined = union_all(hda_q, hdca_q).subquery()
+        stmt = select(combined.c.id, combined.c.hid, combined.c.item_type).order_by(combined.c.hid.desc()).limit(self.limit + 1)
+
+        dataset_ids: set[int] = set()
+        collection_ids: set[int] = set()
+        min_hid: Optional[int] = None
+        max_hid: Optional[int] = None
+        count = 0
+        for row in self.sa_session.execute(stmt):
+            count += 1
+            if count > self.limit:
+                break
+            if row.item_type == "dataset":
+                dataset_ids.add(row.id)
+            else:
+                collection_ids.add(row.id)
+            hid = row.hid
+            if hid is not None:
+                if min_hid is None or hid < min_hid:
+                    min_hid = hid
+                if max_hid is None or hid > max_hid:
+                    max_hid = hid
+        return dataset_ids, collection_ids, count > self.limit, min_hid, max_hid
+
+    def _remove_hidden_elements(self, dataset_ids: set[int]) -> set[int]:
+        if not dataset_ids:
+            return dataset_ids
+        to_remove: set[int] = set()
+        for chunk in self._chunks(list(dataset_ids)):
+            stmt = (
+                select(HistoryDatasetAssociation.id)
+                .join(DatasetCollectionElement, DatasetCollectionElement.hda_id == HistoryDatasetAssociation.id)
+                .where(HistoryDatasetAssociation.id.in_(chunk), HistoryDatasetAssociation.visible == False)  # noqa: E712
+                .distinct()
+            )
+            for row in self.sa_session.execute(stmt):
+                to_remove.add(row.id)
+        return dataset_ids - to_remove
+
+    def _filter_deleted_hdas(self, ids: set[int]) -> set[int]:
+        if not ids:
+            return ids
+        kept: set[int] = set()
+        for chunk in self._chunks(list(ids)):
+            stmt = select(HistoryDatasetAssociation.id).where(
+                HistoryDatasetAssociation.id.in_(chunk),
+                HistoryDatasetAssociation.deleted == False,  # noqa: E712
+            )
+            for row in self.sa_session.execute(stmt):
+                kept.add(row.id)
+        return kept
+
+    def _filter_deleted_hdcas(self, ids: set[int]) -> set[int]:
+        if not ids:
+            return ids
+        kept: set[int] = set()
+        for chunk in self._chunks(list(ids)):
+            stmt = select(HistoryDatasetCollectionAssociation.id).where(
+                HistoryDatasetCollectionAssociation.id.in_(chunk),
+                HistoryDatasetCollectionAssociation.deleted == False,  # noqa: E712
+            )
+            for row in self.sa_session.execute(stmt):
+                kept.add(row.id)
+        return kept
+
+    # ── Producer lookup (strictly minimal) ──
+
+    def _hda_producers(self, dataset_ids: set[int]) -> dict[tuple[str, int], tuple[int, str]]:
+        """JTODA only.  No Dataset.job_id.  No fallback.
+        Collect all candidates first, then emit only items with
+        exactly one distinct producer."""
+        candidates: dict[int, dict[int, str]] = {}  # hda_id -> {tr_id: tool_id}
+        for chunk in self._chunks(list(dataset_ids)):
+            stmt = (
+                select(
+                    JobToOutputDatasetAssociation.dataset_id.label("hda_id"),
+                    Job.tool_request_id,
+                    Job.tool_id,
+                )
+                .join(Job, Job.id == JobToOutputDatasetAssociation.job_id)
+                .where(
+                    JobToOutputDatasetAssociation.dataset_id.in_(chunk),
+                    Job.tool_request_id.isnot(None),
+                    Job.tool_id.isnot(None),
+                    Job.tool_id != "__DATA_FETCH__",
+                )
+            )
+            for row in self.sa_session.execute(stmt):
+                candidates.setdefault(row.hda_id, {})[row.tool_request_id] = row.tool_id
+
+        result: dict[tuple[str, int], tuple[int, str]] = {}
+        for hda_id, tr_map in candidates.items():
+            if len(tr_map) == 1:
+                tr_id, tool_id = next(iter(tr_map.items()))
+                result[("dataset", hda_id)] = (tr_id, tool_id)
+            else:
+                log.debug("history_graph: skipping HDA %d — ambiguous producer (%s)", hda_id, set(tr_map.keys()))
+        return result
+
+    def _hdca_producers(self, collection_ids: set[int]) -> dict[tuple[str, int], tuple[int, str]]:
+        """JODCA only.  No TRICA.  No HDCA.job_id.  No fallback.
+        Collect all candidates first, then emit only items with
+        exactly one distinct producer."""
+        candidates: dict[int, dict[int, str]] = {}
+        for chunk in self._chunks(list(collection_ids)):
+            stmt = (
+                select(
+                    JobToOutputDatasetCollectionAssociation.dataset_collection_id.label("hdca_id"),
+                    Job.tool_request_id,
+                    Job.tool_id,
+                )
+                .join(Job, Job.id == JobToOutputDatasetCollectionAssociation.job_id)
+                .where(
+                    JobToOutputDatasetCollectionAssociation.dataset_collection_id.in_(chunk),
+                    Job.tool_request_id.isnot(None),
+                    Job.tool_id.isnot(None),
+                    Job.tool_id != "__DATA_FETCH__",
+                )
+            )
+            for row in self.sa_session.execute(stmt):
+                candidates.setdefault(row.hdca_id, {})[row.tool_request_id] = row.tool_id
+
+        result: dict[tuple[str, int], tuple[int, str]] = {}
+        for hdca_id, tr_map in candidates.items():
+            if len(tr_map) == 1:
+                tr_id, tool_id = next(iter(tr_map.items()))
+                result[("collection", hdca_id)] = (tr_id, tool_id)
+            else:
+                log.debug("history_graph: skipping HDCA %d — ambiguous producer (%s)", hdca_id, set(tr_map.keys()))
+        return result
+
+    # ── Payload input resolution ──
+
+    def _fetch_payloads(self, tr_ids: set[int]) -> dict[int, dict]:
+        """Batch-fetch all tool_request.request payloads in one query."""
+        result: dict[int, dict] = {}
+        for chunk in self._chunks(list(tr_ids)):
+            stmt = select(ToolRequest.id, ToolRequest.request).where(ToolRequest.id.in_(chunk))
+            for row in self.sa_session.execute(stmt):
+                try:
+                    payload = json.loads(row.request) if isinstance(row.request, str) else row.request
+                    if isinstance(payload, dict):
+                        result[row.id] = payload
+                except (json.JSONDecodeError, TypeError):
+                    log.debug("history_graph: malformed payload for tool_request %d", row.id)
+        return result
+
+    def _extract_inputs(self, payload: dict) -> set[tuple[str, int]]:
+        """Extract and normalize input refs from a single payload."""
+        raw_refs = self._walk_payload(payload)
+        return self._normalize_refs(raw_refs)
+
+    @staticmethod
+    def _walk_payload(obj) -> set[tuple[str, int]]:
+        """Recursively extract {src, id} references.
+        Unknown src types are rejected with a DEBUG log."""
+        refs: set[tuple[str, int]] = set()
+        if isinstance(obj, dict):
+            src = obj.get("src")
+            if src is not None:
+                item_id = obj.get("id")
+                if src in ("hda", "hdca") and isinstance(item_id, int):
+                    refs.add(("dataset" if src == "hda" else "collection", item_id))
+                else:
+                    log.debug("history_graph: rejected unknown payload ref src=%r id=%r", src, item_id)
+                return refs  # leaf ref node, do not recurse into src/id
+            if obj.get("__class__") == "Batch" and "values" in obj:
+                for v in obj["values"]:
+                    refs |= HistoryGraphBuilder._walk_payload(v)
+            else:
+                for k, v in obj.items():
+                    if k != "__class__":
+                        refs |= HistoryGraphBuilder._walk_payload(v)
+        elif isinstance(obj, list):
+            for item in obj:
+                refs |= HistoryGraphBuilder._walk_payload(item)
+        return refs
+
+    def _normalize_refs(self, refs: set[tuple[str, int]]) -> set[tuple[str, int]]:
+        """Single normalization rule: hidden-element HDA → parent HDCA."""
+        result: set[tuple[str, int]] = set()
+        hda_ids = [item_id for t, item_id in refs if t == "dataset"]
+        hdca_parents: dict[int, int] = {}
+        for chunk in self._chunks(hda_ids):
+            stmt = (
+                select(
+                    HistoryDatasetAssociation.id.label("hda_id"),
+                    HistoryDatasetCollectionAssociation.id.label("hdca_id"),
+                )
+                .join(DatasetCollectionElement, DatasetCollectionElement.hda_id == HistoryDatasetAssociation.id)
+                .join(
+                    HistoryDatasetCollectionAssociation,
+                    HistoryDatasetCollectionAssociation.collection_id == DatasetCollectionElement.dataset_collection_id,
+                )
+                .where(
+                    HistoryDatasetAssociation.id.in_(chunk),
+                    HistoryDatasetAssociation.visible == False,  # noqa: E712
+                )
+            )
+            for row in self.sa_session.execute(stmt):
+                hdca_parents[row.hda_id] = row.hdca_id
+
+        for ref_type, ref_id in refs:
+            if ref_type == "dataset" and ref_id in hdca_parents:
+                result.add(("collection", hdca_parents[ref_id]))
+            else:
+                result.add((ref_type, ref_id))
+        return result
+
+    # ── Node construction ──
+
+    def _dataset_nodes(self, db_ids: set[int]) -> list[GraphNode]:
+        nodes = []
+        for chunk in self._chunks(list(db_ids)):
+            stmt = (
+                select(
+                    HistoryDatasetAssociation.id,
+                    HistoryDatasetAssociation.name,
+                    HistoryDatasetAssociation.hid,
+                    HistoryDatasetAssociation._state,
+                    Dataset.state.label("dataset_state"),
+                    HistoryDatasetAssociation.extension,
+                    HistoryDatasetAssociation.deleted,
+                    HistoryDatasetAssociation.visible,
+                )
+                .join(Dataset, HistoryDatasetAssociation.dataset_id == Dataset.id)
+                .where(HistoryDatasetAssociation.id.in_(chunk))
+            )
+            for row in self.sa_session.execute(stmt):
+                nodes.append(GraphNode(
+                    id=self._encode("dataset", row.id),
+                    type="dataset",
+                    name=row.name,
+                    hid=row.hid,
+                    state=row._state if row._state else row.dataset_state,
+                    extension=row.extension,
+                    deleted=row.deleted,
+                    visible=row.visible,
+                ))
+        return nodes
+
+    def _collection_nodes(self, db_ids: set[int]) -> list[GraphNode]:
+        nodes = []
+        for chunk in self._chunks(list(db_ids)):
+            stmt = (
+                select(
+                    HistoryDatasetCollectionAssociation.id,
+                    HistoryDatasetCollectionAssociation.name,
+                    HistoryDatasetCollectionAssociation.hid,
+                    HistoryDatasetCollectionAssociation.deleted,
+                    HistoryDatasetCollectionAssociation.visible,
+                    DatasetCollection.collection_type,
+                    DatasetCollection.populated_state,
+                )
+                .join(DatasetCollection, HistoryDatasetCollectionAssociation.collection_id == DatasetCollection.id)
+                .where(HistoryDatasetCollectionAssociation.id.in_(chunk))
+            )
+            for row in self.sa_session.execute(stmt):
+                nodes.append(GraphNode(
+                    id=self._encode("collection", row.id),
+                    type="collection",
+                    name=row.name,
+                    hid=row.hid,
+                    state=row.populated_state,
+                    collection_type=row.collection_type,
+                    deleted=row.deleted,
+                    visible=row.visible,
+                ))
+        return nodes
+
+    def _tr_nodes(self, tr_map: dict[int, Optional[str]]) -> list[GraphNode]:
+        return [
+            GraphNode(
+                id=self._encode("tool_request", tr_id),
+                type="tool_request",
+                tool_id=tool_id,
+            )
+            for tr_id, tool_id in tr_map.items()
+        ]
+
+    def _resolve_tool_names(self, nodes: list[GraphNode]):
+        tool_ids = {n.tool_id for n in nodes if n.type == "tool_request" and n.tool_id}
+        name_map: dict[str, str] = {}
+        for tool_id in tool_ids:
+            try:
+                tool = self.toolbox.get_tool(tool_id)
+                if tool and tool.name:
+                    name_map[tool_id] = tool.name
+            except Exception:
+                pass
+        for node in nodes:
+            if node.type == "tool_request" and node.tool_id and node.tool_id in name_map:
+                node.tool_name = name_map[node.tool_id]
+
+    # ── Seed subgraph filter (in-memory only) ──
+
+    def _seed_filter(
+        self, nodes: list[GraphNode], edges: list[GraphEdge]
+    ) -> tuple[list[GraphNode], list[GraphEdge]]:
+        from galaxy.exceptions import RequestParameterInvalidException
+
+        if not self.seed or len(self.seed) < 2:
+            raise RequestParameterInvalidException(f"Invalid seed: {self.seed!r}")
+        node_ids = {n.id for n in nodes}
+        if self.seed not in node_ids:
+            raise RequestParameterInvalidException(f"Seed {self.seed} not found in graph.")
+
+        out_map: dict[str, set[str]] = {}
+        in_map: dict[str, set[str]] = {}
+        for e in edges:
+            out_map.setdefault(e.source, set()).add(e.target)
+            in_map.setdefault(e.target, set()).add(e.source)
+
+        reachable: set[str] = {self.seed}
+        frontier = {self.seed}
+        for _ in range(self.depth):
+            nxt: set[str] = set()
+            for nid in frontier:
+                if self.direction in ("forward", "both"):
+                    nxt |= out_map.get(nid, set()) - reachable
+                if self.direction in ("backward", "both"):
+                    nxt |= in_map.get(nid, set()) - reachable
+            if not nxt:
+                break
+            reachable |= nxt
+            frontier = nxt
+        return (
+            [n for n in nodes if n.id in reachable],
+            [e for e in edges if e.source in reachable and e.target in reachable],
+        )
+
+    # ── Sort ──
+
+    def _sort(self, nodes: list[GraphNode], edges: list[GraphEdge]) -> tuple[list[GraphNode], list[GraphEdge]]:
+        fallback = (99, 0)
+        nodes.sort(key=lambda n: self._sort_keys.get(n.id, fallback))
+        edges.sort(key=lambda e: (
+            self._sort_keys.get(e.source, fallback),
+            self._sort_keys.get(e.target, fallback),
+            EDGE_TYPE_RANK.get(e.type, 99),
+        ))
+        return nodes, edges
+
+    # ── Utilities ──
+
+    def _encode(self, node_type: str, db_id: int) -> str:
+        encoded = f"{NODE_TYPE_PREFIX[node_type]}{self.security.encode_id(db_id)}"
+        self._sort_keys[encoded] = (TYPE_RANK[node_type], db_id)
+        return encoded
+
+    @staticmethod
+    def _chunks(items: list) -> list[list]:
+        return [items[i:i + CHUNK] for i in range(0, len(items), CHUNK)] if items else []
diff --git a/lib/galaxy/schema/history_graph.py b/lib/galaxy/schema/history_graph.py
new file mode 100644
index 00000000000..d791214c9e5
--- /dev/null
+++ b/lib/galaxy/schema/history_graph.py
@@ -0,0 +1,40 @@
+from typing import (
+    Literal,
+    Optional,
+)
+
+from pydantic import BaseModel
+
+
+class GraphNode(BaseModel):
+    id: str
+    type: Literal["dataset", "collection", "tool_request"]
+    name: Optional[str] = None
+    hid: Optional[int] = None
+    state: Optional[str] = None
+    extension: Optional[str] = None
+    collection_type: Optional[str] = None
+    deleted: Optional[bool] = None
+    visible: Optional[bool] = None
+    tool_id: Optional[str] = None
+    tool_name: Optional[str] = None
+
+
+class GraphEdge(BaseModel):
+    source: str
+    target: str
+    type: Literal["dataset_input", "dataset_output", "collection_input", "collection_output"]
+
+
+class TruncationInfo(BaseModel):
+    item_count_capped: bool = False
+    scope_type: Literal["recent", "window", "seed_centered"] = "recent"
+    oldest_hid_included: Optional[int] = None
+    newest_hid_included: Optional[int] = None
+    seed_in_scope: Optional[bool] = None
+
+
+class HistoryGraphResponse(BaseModel):
+    nodes: list[GraphNode]
+    edges: list[GraphEdge]
+    truncated: TruncationInfo

From 3cfad1431f40a7f1791f521c1011c49d43a013ae Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:31:17 +0300
Subject: [PATCH 03/28] Add history graph API endpoint and regenerate client
 schema.

---
 client/src/api/schema/schema.ts               | 171 ++++++++++++++++++
 lib/galaxy/webapps/galaxy/api/histories.py    |  60 ++++++
 lib/galaxy/webapps/galaxy/buildapp.py         |   1 +
 .../webapps/galaxy/services/histories.py      |  32 ++++
 4 files changed, 264 insertions(+)

diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index f02125d0832..e03dcf387fc 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -2855,6 +2855,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/histories/{history_id}/graph": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Returns a history-scoped structural graph. */
+        get: operations["graph_api_histories__history_id__graph_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/histories/{history_id}/jobs_summary": {
         parameters: {
             query?: never;
@@ -13106,6 +13123,51 @@ export interface components {
              */
             type: "genomebuild";
         };
+        /** GraphEdge */
+        GraphEdge: {
+            /** Source */
+            source: string;
+            /** Target */
+            target: string;
+            /**
+             * Type
+             * @enum {string}
+             */
+            type: "dataset_input" | "dataset_output" | "collection_input" | "collection_output";
+        };
+        /** GraphNode */
+        GraphNode: {
+            /** Collection Type */
+            collection_type?: string | null;
+            /** Deleted */
+            deleted?: boolean | null;
+            /** Extension */
+            extension?: string | null;
+            /** Hid */
+            hid?: number | null;
+            /** Id */
+            id: string;
+            /** Name */
+            name?: string | null;
+            /**
+             * Partial
+             * @description True if this tool_request has edges on only one side (input or output) within the current graph scope. This can mean the other side is outside the scope window, was suppressed during collapsing, or the tool genuinely has no inputs. None for fully connected tool_requests and non-tool_request nodes.
+             */
+            partial?: boolean | null;
+            /** State */
+            state?: string | null;
+            /** Tool Id */
+            tool_id?: string | null;
+            /** Tool Name */
+            tool_name?: string | null;
+            /**
+             * Type
+             * @enum {string}
+             */
+            type: "dataset" | "collection" | "tool_request";
+            /** Visible */
+            visible?: boolean | null;
+        };
         /**
          * GroupCreatePayload
          * @description Payload schema for creating a group.
@@ -15376,6 +15438,14 @@ export interface components {
              */
             username_and_slug?: string | null;
         };
+        /** HistoryGraphResponse */
+        HistoryGraphResponse: {
+            /** Edges */
+            edges: components["schemas"]["GraphEdge"][];
+            /** Nodes */
+            nodes: components["schemas"]["GraphNode"][];
+            truncated: components["schemas"]["TruncationInfo"];
+        };
         /**
          * HistorySummary
          * @description History summary information.
@@ -23730,6 +23800,46 @@ export interface components {
              */
             title?: string | null;
         };
+        /** TruncationInfo */
+        TruncationInfo: {
+            /**
+             * Item Count Capped
+             * @default false
+             */
+            item_count_capped: boolean;
+            /** Newest Hid Included */
+            newest_hid_included?: number | null;
+            /** Oldest Hid Included */
+            oldest_hid_included?: number | null;
+            /**
+             * Scope Type
+             * @default recent
+             * @enum {string}
+             */
+            scope_type: "recent" | "window" | "seed_centered";
+            /** Seed In Scope */
+            seed_in_scope?: boolean | null;
+            /**
+             * Tool Request Count Capped
+             * @default false
+             */
+            tool_request_count_capped: boolean;
+            /**
+             * Tool Requests Omitted
+             * @default 0
+             */
+            tool_requests_omitted: number;
+            /**
+             * Tool Requests Partial
+             * @default 0
+             */
+            tool_requests_partial: number;
+            /**
+             * Total History Items
+             * @default 0
+             */
+            total_history_items: number;
+        };
         /** UndeleteHistoriesPayload */
         UndeleteHistoriesPayload: {
             /**
@@ -39149,6 +39259,67 @@ export interface operations {
             };
         };
     };
+    graph_api_histories__history_id__graph_get: {
+        parameters: {
+            query?: {
+                /** @description Maximum number of nodes. Applied at history scope. */
+                limit?: number;
+                /** @description Include deleted datasets and collections. */
+                include_deleted?: boolean;
+                /** @description Optional: focus on subgraph reachable from this node (e.g. d<encoded_id>). */
+                seed?: string | null;
+                /** @description Direction for seed-based subgraph extraction. */
+                direction?: "backward" | "forward" | "both";
+                /** @description Max depth for seed-based subgraph extraction. */
+                depth?: number;
+                /** @description Pagination: select items with hid less than this value (older items). */
+                older_than_hid?: number | null;
+                /** @description Pagination: select items with hid greater than this value (newer items). */
+                newer_than_hid?: number | null;
+                /** @description Center the selection window on this item's hid position. Format: d{encoded_id} or c{encoded_id}. */
+                seed_scope?: string | null;
+            };
+            header?: {
+                /** @description The user ID that will be used to effectively make this API call. Only admins and designated users can make API calls on behalf of other users. */
+                "run-as"?: string | null;
+            };
+            path: {
+                /** @description The encoded database identifier of the History. */
+                history_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HistoryGraphResponse"];
+                };
+            };
+            /** @description Request Error */
+            "4XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+            /** @description Server Error */
+            "5XX": {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageExceptionModel"];
+                };
+            };
+        };
+    };
     index_jobs_summary_api_histories__history_id__jobs_summary_get: {
         parameters: {
             query?: {
diff --git a/lib/galaxy/webapps/galaxy/api/histories.py b/lib/galaxy/webapps/galaxy/api/histories.py
index c1d847ec6ab..d9fcd06b02c 100644
--- a/lib/galaxy/webapps/galaxy/api/histories.py
+++ b/lib/galaxy/webapps/galaxy/api/histories.py
@@ -48,6 +48,7 @@ from galaxy.schema.history import (
     HistoryIndexQueryPayload,
     HistorySortByEnum,
 )
+from galaxy.schema.history_graph import HistoryGraphResponse
 from galaxy.schema.schema import (
     AnyArchivedHistoryView,
     AnyHistoryView,
@@ -357,6 +358,65 @@ class FastAPIHistories:
     ) -> AnyHistoryView:
         return self.service.show(trans, serialization_params, history_id)
 
+    @router.get(
+        "/api/histories/{history_id}/graph",
+        summary="Returns a history-scoped structural graph.",
+    )
+    def graph(
+        self,
+        history_id: HistoryIDPathParam,
+        limit: int = Query(
+            default=500,
+            description="Maximum number of nodes. Applied at history scope.",
+            ge=1,
+            le=2000,
+        ),
+        include_deleted: bool = Query(
+            default=False,
+            description="Include deleted datasets and collections.",
+        ),
+        seed: Optional[str] = Query(
+            default=None,
+            description="Optional: focus on subgraph reachable from this node (e.g. d<encoded_id>).",
+            pattern=r"^[dcr].+$",
+        ),
+        direction: Literal["backward", "forward", "both"] = Query(
+            default="both",
+            description="Direction for seed-based subgraph extraction.",
+        ),
+        depth: int = Query(
+            default=20,
+            description="Max depth for seed-based subgraph extraction.",
+            ge=1,
+            le=20,
+        ),
+        older_than_hid: Optional[int] = Query(
+            default=None,
+            description="Pagination: select items with hid less than this value (older items).",
+        ),
+        newer_than_hid: Optional[int] = Query(
+            default=None,
+            description="Pagination: select items with hid greater than this value (newer items).",
+        ),
+        seed_scope: Optional[str] = Query(
+            default=None,
+            description="Center the selection window on this item's hid position. Format: d{encoded_id} or c{encoded_id}.",
+        ),
+        trans: ProvidesHistoryContext = DependsOnTrans,
+    ) -> HistoryGraphResponse:
+        return self.service.graph(
+            trans,
+            history_id,
+            limit=limit,
+            include_deleted=include_deleted,
+            seed=seed,
+            direction=direction,
+            depth=depth,
+            older_than_hid=older_than_hid,
+            newer_than_hid=newer_than_hid,
+            seed_scope=seed_scope,
+        )
+
     @router.post(
         "/api/histories/{history_id}/prepare_store_download",
         summary="Return a short term storage token to monitor download of the history.",
diff --git a/lib/galaxy/webapps/galaxy/buildapp.py b/lib/galaxy/webapps/galaxy/buildapp.py
index 79f5f029573..7f42cf3719c 100644
--- a/lib/galaxy/webapps/galaxy/buildapp.py
+++ b/lib/galaxy/webapps/galaxy/buildapp.py
@@ -276,6 +276,7 @@ def app_pair(global_conf, load_app_kwds=None, wsgi_preflight=True, **kwargs):
     webapp.add_client_route("/histories/{history_id}/extract_workflow")
     webapp.add_client_route("/histories/{history_id}/archive")
     webapp.add_client_route("/histories/{history_id}/invocations")
+    webapp.add_client_route("/histories/{history_id}/graph")
     webapp.add_client_route("/histories/archived")
     webapp.add_client_route("/histories/list_published")
     webapp.add_client_route("/histories/list_shared")
diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index 097fbc1c96f..d0da29f9474 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -40,6 +40,7 @@ from galaxy.managers.histories import (
     HistoryManager,
     HistorySerializer,
 )
+from galaxy.managers.history_graph import HistoryGraphBuilder
 from galaxy.managers.users import UserManager
 from galaxy.model import HistoryDatasetAssociation
 from galaxy.model.scoped_session import galaxy_scoped_session
@@ -379,6 +380,37 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
             history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
         return self._serialize_history(trans, history, serialization_params)
 
+    def graph(
+        self,
+        trans: ProvidesHistoryContext,
+        history_id: DecodedDatabaseIdField,
+        limit: int = 500,
+        include_deleted: bool = False,
+        seed: Optional[str] = None,
+        direction: str = "both",
+        depth: int = 20,
+        older_than_hid: Optional[int] = None,
+        newer_than_hid: Optional[int] = None,
+        seed_scope: Optional[str] = None,
+    ):
+        history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
+        toolbox = getattr(trans.app, "toolbox", None)
+        builder = HistoryGraphBuilder(
+            sa_session=trans.sa_session,
+            security=self.security,
+            history_id=history.id,
+            limit=limit,
+            toolbox=toolbox,
+            include_deleted=include_deleted,
+            seed=seed,
+            direction=direction,
+            depth=depth,
+            older_than_hid=older_than_hid,
+            newer_than_hid=newer_than_hid,
+            seed_scope=seed_scope,
+        )
+        return builder.build()
+
     def prepare_download(
         self, trans: ProvidesHistoryContext, history_id: DecodedDatabaseIdField, payload: StoreExportPayload
     ) -> AsyncFile:

From 2c78e5c9ff877b7cee749f59e67c6ec6af98dabc Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:31:19 +0300
Subject: [PATCH 04/28] Add unit tests for history graph builder.

---
 .../app/managers/test_HistoryGraphBuilder.py  | 1949 +++++++++++++++++
 1 file changed, 1949 insertions(+)
 create mode 100644 test/unit/app/managers/test_HistoryGraphBuilder.py

diff --git a/test/unit/app/managers/test_HistoryGraphBuilder.py b/test/unit/app/managers/test_HistoryGraphBuilder.py
new file mode 100644
index 00000000000..ecc1c9f7527
--- /dev/null
+++ b/test/unit/app/managers/test_HistoryGraphBuilder.py
@@ -0,0 +1,1949 @@
+import os
+
+import pytest
+
+from galaxy import model
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.managers.collections import DatasetCollectionManager
+from galaxy.managers.datasets import DatasetManager
+from galaxy.managers.hdas import HDAManager
+from galaxy.managers.histories import HistoryManager
+from galaxy.managers.history_graph import HistoryGraphBuilder
+from .base import (
+    BaseTestCase,
+    CreatesCollectionsMixin,
+)
+
+default_password = "123456"
+_user_counter = 0
+
+
+def _next_user_data():
+    global _user_counter
+    _user_counter += 1
+    return dict(
+        email=f"graphuser{_user_counter}@test.test",
+        username=f"graphuser{_user_counter}",
+        password=default_password,
+    )
+
+
+class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
+    def set_up_managers(self):
+        super().set_up_managers()
+        self.dataset_manager = self.app[DatasetManager]
+        self.hda_manager = self.app[HDAManager]
+        self.history_manager = self.app[HistoryManager]
+        self.collection_manager = self.app[DatasetCollectionManager]
+
+    def _build_graph(
+        self,
+        history,
+        seed=None,
+        direction="both",
+        depth=20,
+        limit=500,
+        older_than_hid=None,
+        newer_than_hid=None,
+        seed_scope=None,
+    ):
+        builder = HistoryGraphBuilder(
+            sa_session=self.trans.sa_session,
+            security=self.app.security,
+            history_id=history.id,
+            limit=limit,
+            seed=seed,
+            direction=direction,
+            depth=depth,
+            older_than_hid=older_than_hid,
+            newer_than_hid=newer_than_hid,
+            seed_scope=seed_scope,
+        )
+        return builder.build()
+
+    def _encode(self, prefix, db_id):
+        return f"{prefix}{self.app.security.encode_id(db_id)}"
+
+    def _create_history(self):
+        user = self.user_manager.create(**_next_user_data())
+        self.trans.set_user(user)
+        return self.history_manager.create(name="test_history", user=user), user
+
+    def _create_hda(self, history, name="test_dataset", extension="txt"):
+        hda = self.hda_manager.create(name=name, history=history, dataset=self.dataset_manager.create())
+        hda.extension = extension
+        self.trans.sa_session.flush()
+        return hda
+
+    def _create_tool_source(self):
+        ts = model.ToolSource()
+        ts.hash = "abc123"
+        ts.source = {"xml": "<tool/>"}
+        ts.source_class = "XmlToolSource"
+        session = self.trans.sa_session
+        session.add(ts)
+        session.flush()
+        return ts
+
+    def _create_tool_request(self, history, request_data=None, state="submitted"):
+        ts = self._create_tool_source()
+        tr = model.ToolRequest()
+        tr.tool_source_id = ts.id
+        tr.history_id = history.id
+        tr.request = request_data or {}
+        tr.state = state
+        session = self.trans.sa_session
+        session.add(tr)
+        session.flush()
+        return tr
+
+    def _create_job(self, tool_request=None, tool_id="test_tool", tool_version="1.0"):
+        job = model.Job()
+        job.tool_id = tool_id
+        job.tool_version = tool_version
+        if tool_request:
+            job.tool_request_id = tool_request.id
+        session = self.trans.sa_session
+        session.add(job)
+        session.flush()
+        return job
+
+    def _link_job_input_hda(self, job, hda, name="input"):
+        assoc = model.JobToInputDatasetAssociation(name=name, dataset=hda)
+        assoc.job_id = job.id
+        session = self.trans.sa_session
+        session.add(assoc)
+        session.flush()
+        return assoc
+
+    def _link_job_output_hda(self, job, hda, name="output"):
+        assoc = model.JobToOutputDatasetAssociation(name=name, dataset=hda)
+        assoc.job_id = job.id
+        # Mirror production behavior (Job.add_output_dataset, model/__init__.py).
+        # The lean builder resolves HDA producers via Dataset.job_id (Rule N1,
+        # copy-safe), so the test fixture must also wire up that edge.
+        if hda.dataset.job_id is None:
+            hda.dataset.job_id = job.id
+        session = self.trans.sa_session
+        session.add(assoc)
+        session.flush()
+        return assoc
+
+    def _link_job_input_hdca(self, job, hdca, name="input"):
+        assoc = model.JobToInputDatasetCollectionAssociation(name=name, dataset_collection=hdca)
+        assoc.job_id = job.id
+        session = self.trans.sa_session
+        session.add(assoc)
+        session.flush()
+        return assoc
+
+    def _link_job_output_hdca(self, job, hdca, name="output"):
+        # Mirrors production: ``Job.add_output_dataset_collection`` only
+        # creates the JobToOutputDatasetCollectionAssociation row.  It
+        # does NOT set ``HDCA.job_id``.  The history graph builder must
+        # therefore discover HDCA producers via the JobToOutput table,
+        # not via HDCA.job_id alone.  Earlier versions of this helper
+        # also set hdca.job_id which masked a real bug.
+        assoc = model.JobToOutputDatasetCollectionAssociation(name=name, dataset_collection_instance=hdca)
+        assoc.job_id = job.id
+        session = self.trans.sa_session
+        session.add(assoc)
+        session.flush()
+        return assoc
+
+    def _link_implicit_collection(self, tool_request, hdca, output_name="output"):
+        assoc = model.ToolRequestImplicitCollectionAssociation()
+        assoc.tool_request_id = tool_request.id
+        assoc.dataset_collection_id = hdca.id
+        assoc.output_name = output_name
+        session = self.trans.sa_session
+        session.add(assoc)
+        session.flush()
+        return assoc
+
+    def _build_linear_chain(self, history, length=3):
+        """Build A -> tr1 -> B -> tr2 -> C -> ... Returns list of (hda, tool_request) pairs."""
+        chain = []
+        prev_hda = self._create_hda(history, name="input_0", extension="fastq")
+        for i in range(length):
+            tr = self._create_tool_request(history)
+            job = self._create_job(tool_request=tr, tool_id=f"tool_{i}")
+            self._link_job_input_hda(job, prev_hda)
+            next_hda = self._create_hda(history, name=f"output_{i}", extension="bam")
+            self._link_job_output_hda(job, next_hda)
+            chain.append((prev_hda, tr, next_hda))
+            prev_hda = next_hda
+        return chain
+
+    # ── History-scoped graph tests ──
+
+    def test_empty_history(self):
+        """Empty history produces empty graph."""
+        history, _ = self._create_history()
+        graph = self._build_graph(history)
+
+        assert len(graph.nodes) == 0
+        assert len(graph.edges) == 0
+        assert graph.truncated.scope_type == "recent"
+        assert graph.truncated.oldest_hid_included is None
+        assert graph.truncated.newest_hid_included is None
+        assert graph.truncated.seed_in_scope is None
+
+    def test_standalone_datasets_included(self):
+        """Standalone datasets (uploads) appear as isolated nodes."""
+        history, _ = self._create_history()
+        self._create_hda(history, name="uploaded.fastq")
+        self._create_hda(history, name="another.bam")
+        graph = self._build_graph(history)
+        assert len(graph.nodes) == 2
+        assert len(graph.edges) == 0
+        assert graph.truncated.oldest_hid_included is not None
+        assert graph.truncated.newest_hid_included is not None
+        assert graph.truncated.newest_hid_included >= graph.truncated.oldest_hid_included
+        
+    def test_full_history_graph(self):
+        """Full history graph includes all items and edges."""
+        history, _ = self._create_history()
+        input_hda = self._create_hda(history, name="input.fastq", extension="fastq")
+        output_hda = self._create_hda(history, name="output.bam", extension="bam")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="bwa_mem")
+        self._link_job_input_hda(job, input_hda)
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+
+        assert len(graph.nodes) == 3  # input + output + tool_request
+        assert len(graph.edges) == 2  # dataset_input + dataset_output
+
+        types = {n.type for n in graph.nodes}
+        assert types == {"dataset", "tool_request"}
+
+        edge_types = {e.type for e in graph.edges}
+        assert edge_types == {"dataset_input", "dataset_output"}
+
+    def test_disconnected_components(self):
+        """Disconnected lineage branches are both included."""
+        history, _ = self._create_history()
+        # Branch 1
+        hda1 = self._create_hda(history, name="input1")
+        out1 = self._create_hda(history, name="output1")
+        tr1 = self._create_tool_request(history)
+        job1 = self._create_job(tool_request=tr1, tool_id="tool1")
+        self._link_job_input_hda(job1, hda1)
+        self._link_job_output_hda(job1, out1)
+
+        # Branch 2 (disconnected)
+        hda2 = self._create_hda(history, name="input2")
+        out2 = self._create_hda(history, name="output2")
+        tr2 = self._create_tool_request(history)
+        job2 = self._create_job(tool_request=tr2, tool_id="tool2")
+        self._link_job_input_hda(job2, hda2)
+        self._link_job_output_hda(job2, out2)
+
+        # Standalone upload
+        self._create_hda(history, name="standalone")
+
+        graph = self._build_graph(history)
+        assert len(graph.nodes) == 7  # 5 datasets + 2 tool_requests
+        assert len(graph.edges) == 4
+
+    def test_data_fetch_excluded(self):
+        """__DATA_FETCH__ tool_requests are excluded."""
+        history, _ = self._create_history()
+        tr = self._create_tool_request(history)
+        self._create_job(tool_request=tr, tool_id="__DATA_FETCH__")
+
+        graph = self._build_graph(history)
+        tr_nodes = [n for n in graph.nodes if n.type == "tool_request"]
+        assert len(tr_nodes) == 0
+
+    def test_collection_node(self):
+        """Collections appear as atomic nodes."""
+        history, _ = self._create_history()
+        hda1 = self._create_hda(history, name="el1")
+        hda2 = self._create_hda(history, name="el2")
+        element_identifiers = self.build_element_identifiers([hda1, hda2])
+        hdca = self.collection_manager.create(
+            self.trans, history, "test list", "list", element_identifiers=element_identifiers
+        )
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="list_tool")
+        self._link_job_input_hdca(job, hdca)
+
+        graph = self._build_graph(history)
+        collection_nodes = [n for n in graph.nodes if n.type == "collection"]
+        assert len(collection_nodes) == 1
+        assert collection_nodes[0].collection_type == "list"
+
+    def test_element_input_resolves_to_top_level_item(self):
+        """When a tool consumes an element HDA that is also a top-level history
+        item, the input edge points to the dataset (not the collection)."""
+        history, _ = self._create_history()
+        hda1 = self._create_hda(history, name="el1")
+        element_identifiers = self.build_element_identifiers([hda1])
+        self.collection_manager.create(
+            self.trans, history, "input list", "list", element_identifiers=element_identifiers
+        )
+        output_hda = self._create_hda(history, name="output")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="element_tool")
+        self._link_job_input_hda(job, hda1)  # Element but also top-level
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+
+        # hda1 is a top-level history item — input edge stays as dataset
+        input_edges = [e for e in graph.edges if e.type == "dataset_input"]
+        assert len(input_edges) >= 1
+        assert any(e.source == self._encode("d", hda1.id) for e in input_edges)
+
+    def test_edge_deduplication(self):
+        """Multiple element edges collapse to one semantic edge."""
+        history, _ = self._create_history()
+        input_hda = self._create_hda(history, name="input")
+        output_hda = self._create_hda(history, name="output")
+        tr = self._create_tool_request(history)
+        job1 = self._create_job(tool_request=tr, tool_id="tool")
+        job2 = self._create_job(tool_request=tr, tool_id="tool")
+        self._link_job_input_hda(job1, input_hda)
+        self._link_job_input_hda(job2, input_hda)
+        self._link_job_output_hda(job1, output_hda)
+        self._link_job_output_hda(job2, output_hda)
+
+        graph = self._build_graph(history)
+        edge_keys = [(e.source, e.target, e.type) for e in graph.edges]
+        assert len(edge_keys) == len(set(edge_keys))
+
+    def test_dataset_node_fields(self):
+        """Dataset nodes contain name, hid, and extension."""
+        history, _ = self._create_history()
+        hda = self._create_hda(history, name="test.fastq", extension="fastq")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="tool")
+        self._link_job_output_hda(job, hda)
+
+        graph = self._build_graph(history)
+        dataset_node = [n for n in graph.nodes if n.type == "dataset" and n.name == "test.fastq"][0]
+        assert dataset_node.hid is not None
+        assert dataset_node.extension == "fastq"
+
+    def test_node_limit(self):
+        """Node limit caps the graph at history scope."""
+        history, _ = self._create_history()
+        for i in range(10):
+            self._create_hda(history, name=f"dataset_{i}")
+
+        graph = self._build_graph(history, limit=5)
+        assert len(graph.nodes) == 5
+        assert graph.truncated.item_count_capped is True
+
+    def test_deterministic_ordering(self):
+        """Identical calls produce identical output."""
+        history, _ = self._create_history()
+        self._build_linear_chain(history, length=3)
+
+        graph1 = self._build_graph(history)
+        graph2 = self._build_graph(history)
+        assert [n.id for n in graph1.nodes] == [n.id for n in graph2.nodes]
+        assert [(e.source, e.target, e.type) for e in graph1.edges] == [
+            (e.source, e.target, e.type) for e in graph2.edges
+        ]
+
+    def test_edge_types_semantic(self):
+        """Edges use semantic types."""
+        history, _ = self._create_history()
+        input_hda = self._create_hda(history, name="input")
+        hda1 = self._create_hda(history, name="el1")
+        element_identifiers = self.build_element_identifiers([hda1])
+        input_hdca = self.collection_manager.create(
+            self.trans, history, "input list", "list", element_identifiers=element_identifiers
+        )
+        output_hda = self._create_hda(history, name="output")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="tool")
+        self._link_job_input_hda(job, input_hda)
+        self._link_job_input_hdca(job, input_hdca)
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+        edge_types = {e.type for e in graph.edges}
+        assert "dataset_input" in edge_types
+        assert "collection_input" in edge_types
+        assert "dataset_output" in edge_types
+
+    def test_seed_subgraph_filter(self):
+        """Seed parameter extracts a subgraph from the full graph."""
+        history, _ = self._create_history()
+        chain = self._build_linear_chain(history, length=3)
+        # Add a disconnected standalone
+        self._create_hda(history, name="standalone")
+
+        full_graph = self._build_graph(history)
+        seed = self._encode("d", chain[0][0].id)
+        filtered = self._build_graph(history, seed=seed, direction="forward", depth=2)
+
+        assert len(filtered.nodes) < len(full_graph.nodes)
+        # Standalone should not be in filtered graph
+        standalone_nodes = [n for n in filtered.nodes if n.name == "standalone"]
+        assert len(standalone_nodes) == 0
+
+    def test_seed_not_in_graph(self):
+        """Seed referencing nonexistent node raises error."""
+        history, _ = self._create_history()
+        fake_seed = self._encode("d", 999999)
+        with pytest.raises(RequestParameterInvalidException):
+            self._build_graph(history, seed=fake_seed)
+
+    def test_no_self_loops(self):
+        """No edge has source == target."""
+        history, _ = self._create_history()
+        self._build_linear_chain(history, length=3)
+        graph = self._build_graph(history)
+        for e in graph.edges:
+            assert e.source != e.target, f"Self-loop: {e.source}"
+
+    def test_seed_scope_centers_on_item(self):
+        """seed_scope centers the selection window on the specified item's hid."""
+        history, _ = self._create_history()
+        # Create 10 standalone datasets
+        hdas = [self._create_hda(history, name=f"dataset_{i}") for i in range(10)]
+
+        # Use seed_scope to center on the middle item (limit=4 → should get ~4 items around it)
+        middle = hdas[5]
+        seed_scope = self._encode("d", middle.id)
+        graph = self._build_graph(history, seed_scope=seed_scope, limit=4)
+
+        assert len(graph.nodes) <= 4
+        # The seed item must be in scope
+        node_ids = {n.id for n in graph.nodes}
+        assert seed_scope in node_ids
+        # Scope metadata should reflect the window
+        assert graph.truncated.scope_type == "seed_centered"
+        assert graph.truncated.oldest_hid_included is not None
+        assert graph.truncated.newest_hid_included is not None
+        assert graph.truncated.oldest_hid_included <= middle.hid <= graph.truncated.newest_hid_included
+
+    def test_pagination_scope_type(self):
+        """Pagination params produce scope_type='window'."""
+        history, _ = self._create_history()
+        for i in range(5):
+            self._create_hda(history, name=f"dataset_{i}")
+        graph = self._build_graph(history, older_than_hid=4)
+        assert graph.truncated.scope_type == "window"
+
+    def test_seed_in_scope_true(self):
+        """seed_in_scope is true when seed is in the constructed graph."""
+        history, _ = self._create_history()
+        chain = self._build_linear_chain(history, length=1)
+        input_hda = chain[0][0]
+        seed = self._encode("d", input_hda.id)
+        graph = self._build_graph(history, seed=seed)
+        assert graph.truncated.seed_in_scope is True
+
+    def test_seed_in_scope_none_without_seed(self):
+        """seed_in_scope is None when no seed is requested."""
+        history, _ = self._create_history()
+        self._create_hda(history, name="dataset")
+        graph = self._build_graph(history)
+        assert graph.truncated.seed_in_scope is None
+
+    def test_seed_scope_not_found(self):
+        """seed_scope with nonexistent item returns 422."""
+        history, _ = self._create_history()
+        self._create_hda(history, name="dataset")
+        fake_scope = f"d{self.app.security.encode_id(99999)}"
+        with pytest.raises(RequestParameterInvalidException):
+            self._build_graph(history, seed_scope=fake_scope)
+
+    def test_seed_scope_invalid_prefix(self):
+        """seed_scope with invalid prefix returns 422."""
+        history, _ = self._create_history()
+        with pytest.raises(RequestParameterInvalidException):
+            self._build_graph(history, seed_scope="x_invalid")
+
+    # ── Step 5: Validation tests ──
+
+    def test_map_over_input_edges(self):
+        """Element inputs from a collection produce dataset_input edges to the consuming execution."""
+        history, _ = self._create_history()
+        el1 = self._create_hda(history, name="el1")
+        el2 = self._create_hda(history, name="el2")
+        element_identifiers = self.build_element_identifiers([el1, el2])
+        self.collection_manager.create(
+            self.trans, history, "input list", "list", element_identifiers=element_identifiers
+        )
+        output_hda = self._create_hda(history, name="mapped_output")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="map_tool")
+        self._link_job_input_hda(job, el1, name="input")
+        self._link_job_input_hda(job, el2, name="input")
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        # Consumer edges: selected element items → execution
+        input_edges = [e for e in graph.edges if e.target == tr_enc and "input" in e.type]
+        assert len(input_edges) == 2  # one per element
+        # Producer edge: execution → output
+        output_edges = [e for e in graph.edges if e.source == tr_enc]
+        assert len(output_edges) == 1
+
+    def test_map_over_output_edges(self):
+        """Element outputs produce dataset_output edges from the producing execution."""
+        history, _ = self._create_history()
+        input_hda = self._create_hda(history, name="input")
+        out_el1 = self._create_hda(history, name="out_el1")
+        out_el2 = self._create_hda(history, name="out_el2")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="map_tool")
+        self._link_job_input_hda(job, input_hda)
+        self._link_job_output_hda(job, out_el1)
+        self._link_job_output_hda(job, out_el2)
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        # Producer edges: execution → each output element
+        output_edges = [e for e in graph.edges if e.source == tr_enc and "output" in e.type]
+        assert len(output_edges) == 2
+        # Consumer edge: input → execution
+        input_edges = [e for e in graph.edges if e.target == tr_enc]
+        assert len(input_edges) == 1
+
+    def test_deleted_input_not_in_consumer_edges(self):
+        """A deleted input HDA is excluded from scope and produces no consumer edge.
+
+        The bounded model only creates consumer edges for selected items.
+        A deleted HDA is not selected (unless include_deleted=True).
+        """
+        history, _ = self._create_history()
+        dataset = self.dataset_manager.create()
+        execution_hda = self.hda_manager.create(name="execution", history=history, dataset=dataset)
+        execution_hda.deleted = True
+        visible_copy = self.hda_manager.create(name="visible_copy", history=history, dataset=dataset)
+        visible_copy.visible = True
+        output_hda = self._create_hda(history, name="output")
+        self.trans.sa_session.flush()
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="copy_tool")
+        self._link_job_input_hda(job, execution_hda)
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        # No consumer edge for deleted execution_hda (not in scope)
+        input_edges = [e for e in graph.edges if e.target == tr_enc and e.type == "dataset_input"]
+        assert len(input_edges) == 0
+
+    def test_hidden_non_element_hda_included(self):
+        """Hidden HDAs that are NOT collection elements appear as graph nodes."""
+        history, _ = self._create_history()
+        hidden_hda = self._create_hda(history, name="hidden_intermediate")
+        hidden_hda.visible = False
+        self.trans.sa_session.flush()
+        output_hda = self._create_hda(history, name="output")
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="tool")
+        self._link_job_input_hda(job, hidden_hda)
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+
+        hidden_enc = self._encode("d", hidden_hda.id)
+        node_ids = {n.id for n in graph.nodes}
+        assert hidden_enc in node_ids
+
+    def test_closure_completes_tool_requests_at_seed_boundary(self):
+        """Closure rule: a tool_request whose other side falls outside
+        the seed window is still structurally complete in the response.
+
+        Old behavior: tool_request kept, but its boundary item omitted —
+        the visualization showed a half-connected execution node.
+        New behavior (closure rule, locked 2026-04-09): the boundary
+        item is pulled in by Stage 5 closure expansion so the
+        tool_request always has all its top-level inputs and outputs.
+        """
+        history, _ = self._create_history()
+        input_hda = self._create_hda(history, name="input")
+        output_hda = self._create_hda(history, name="output")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="tool")
+        self._link_job_input_hda(job, input_hda)
+        self._link_job_output_hda(job, output_hda)
+
+        # Use limit=1 — seed window holds only one item.  Closure must
+        # pull in the other side so the tool_request is complete.
+        graph = self._build_graph(history, limit=1)
+
+        tr_nodes = [n for n in graph.nodes if n.type == "tool_request"]
+        assert len(tr_nodes) == 1
+        assert graph.truncated.item_count_capped is True
+
+        # Closure pulled in the boundary item.
+        assert graph.truncated.closure_items_added >= 1
+        node_ids = {n.id for n in graph.nodes}
+        assert self._encode("d", input_hda.id) in node_ids
+        assert self._encode("d", output_hda.id) in node_ids
+
+        # The tool_request has BOTH input and output edges.
+        tr_enc = self._encode("r", tr.id)
+        in_edges = [e for e in graph.edges if e.target == tr_enc and e.type == "dataset_input"]
+        out_edges = [e for e in graph.edges if e.source == tr_enc and e.type == "dataset_output"]
+        assert len(in_edges) == 1, "tool_request must have its top-level input edge after closure"
+        assert len(out_edges) == 1, "tool_request must have its top-level output edge after closure"
+
+    def test_deleted_items_with_include_deleted(self):
+        """Deleted items appear when include_deleted=True."""
+        history, _ = self._create_history()
+        hda = self._create_hda(history, name="to_delete")
+        hda.deleted = True
+        self.trans.sa_session.flush()
+
+        # Without include_deleted: not included
+        graph = self._build_graph(history)
+        assert len(graph.nodes) == 0
+
+        # With include_deleted: included
+        builder = HistoryGraphBuilder(
+            sa_session=self.trans.sa_session,
+            security=self.app.security,
+            history_id=history.id,
+            include_deleted=True,
+        )
+        graph = builder.build()
+        assert len(graph.nodes) == 1
+
+    def test_pagination_no_overlap(self):
+        """Consecutive pages share no items."""
+        history, _ = self._create_history()
+        for i in range(10):
+            self._create_hda(history, name=f"ds_{i}")
+
+        # Page 1: most recent 5
+        page1 = self._build_graph(history, limit=5)
+        page1_ids = {n.id for n in page1.nodes}
+        oldest_hid = page1.truncated.oldest_hid_included
+
+        # Page 2: older than page 1's oldest
+        page2 = self._build_graph(history, limit=5, older_than_hid=oldest_hid)
+        page2_ids = {n.id for n in page2.nodes}
+
+        assert len(page1_ids & page2_ids) == 0, "Pages must not overlap"
+        assert len(page1_ids) + len(page2_ids) == 10
+
+    def test_determinism_identical_requests(self):
+        """Identical requests produce identical output."""
+        history, _ = self._create_history()
+        self._build_linear_chain(history, length=3)
+
+        graph1 = self._build_graph(history)
+        graph2 = self._build_graph(history)
+
+        assert [n.id for n in graph1.nodes] == [n.id for n in graph2.nodes]
+        assert [(e.source, e.target, e.type) for e in graph1.edges] == [
+            (e.source, e.target, e.type) for e in graph2.edges
+        ]
+
+    def test_expanding_limit_generally_additive(self):
+        """Expanding limit is generally additive for standalone datasets.
+
+        Note: collapse rules (map-over, representability) mean this is not
+        a hard invariant — adding items to scope can change which tool_requests
+        are representable. This test covers the simple case.
+        """
+        history, _ = self._create_history()
+        for i in range(8):
+            self._create_hda(history, name=f"ds_{i}")
+
+        small = self._build_graph(history, limit=4)
+        large = self._build_graph(history, limit=8)
+
+        small_ids = {n.id for n in small.nodes}
+        large_ids = {n.id for n in large.nodes}
+        # All nodes in the small graph should also be in the large graph
+        assert small_ids.issubset(large_ids)
+        assert len(large_ids) >= len(small_ids)
+
+    # ── Zip / Unzip / Collection tests ──
+
+    def test_zip_collection(self):
+        """Zip: two input datasets → tool → one output paired collection.
+
+        Verifies: dataset_input edges from both inputs, collection_output to
+        the paired collection, no self-loops, no false edges.
+        """
+        history, _ = self._create_history()
+        fwd = self._create_hda(history, name="forward.fastq")
+        rev = self._create_hda(history, name="reverse.fastq")
+
+        # Output: paired collection containing elements referencing fwd/rev
+        element_identifiers = self.build_element_identifiers([fwd, rev])
+        output_hdca = self.collection_manager.create(
+            self.trans, history, "zipped pairs", "paired", element_identifiers=element_identifiers
+        )
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="__ZIP_COLLECTION__")
+        self._link_job_input_hda(job, fwd, name="forward")
+        self._link_job_input_hda(job, rev, name="reverse")
+        self._link_job_output_hdca(job, output_hdca)
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        fwd_enc = self._encode("d", fwd.id)
+        rev_enc = self._encode("d", rev.id)
+        coll_enc = self._encode("c", output_hdca.id)
+
+        # Two dataset_input edges
+        input_edges = [e for e in graph.edges if e.target == tr_enc and e.type == "dataset_input"]
+        input_sources = {e.source for e in input_edges}
+        assert input_sources == {fwd_enc, rev_enc}
+
+        # One collection_output edge
+        output_edges = [e for e in graph.edges if e.source == tr_enc and e.type == "collection_output"]
+        assert len(output_edges) == 1
+        assert output_edges[0].target == coll_enc
+
+        # No self-loops
+        for e in graph.edges:
+            assert e.source != e.target
+
+    def test_unzip_collection(self):
+        """Unzip: one input paired collection → tool → two output datasets.
+
+        Verifies: collection_input from the paired collection, dataset_output
+        edges to both outputs, no false input edges from output datasets.
+        """
+        history, _ = self._create_history()
+        el1 = self._create_hda(history, name="el1")
+        el2 = self._create_hda(history, name="el2")
+        element_identifiers = self.build_element_identifiers([el1, el2])
+        input_hdca = self.collection_manager.create(
+            self.trans, history, "paired input", "paired", element_identifiers=element_identifiers
+        )
+
+        out1 = self._create_hda(history, name="unzipped_1")
+        out2 = self._create_hda(history, name="unzipped_2")
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="__UNZIP_COLLECTION__")
+        self._link_job_input_hdca(job, input_hdca)
+        self._link_job_output_hda(job, out1, name="forward")
+        self._link_job_output_hda(job, out2, name="reverse")
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        coll_enc = self._encode("c", input_hdca.id)
+        out1_enc = self._encode("d", out1.id)
+        out2_enc = self._encode("d", out2.id)
+
+        # One collection_input edge
+        input_edges = [e for e in graph.edges if e.target == tr_enc and "input" in e.type]
+        assert len(input_edges) == 1
+        assert input_edges[0].source == coll_enc
+        assert input_edges[0].type == "collection_input"
+
+        # Two dataset_output edges
+        output_edges = [e for e in graph.edges if e.source == tr_enc and e.type == "dataset_output"]
+        output_targets = {e.target for e in output_edges}
+        assert output_targets == {out1_enc, out2_enc}
+
+        # No self-loops
+        for e in graph.edges:
+            assert e.source != e.target
+
+    def test_unzip_with_shared_dataset_ids(self):
+        """Unzip where outputs share dataset_id with input collection elements.
+
+        When a tool has a collection input AND element-level dataset inputs
+        (some Galaxy wrappers do this), and resolved dataset inputs point to
+        outputs, the false input edges must be suppressed.
+        """
+        history, _ = self._create_history()
+        # Shared datasets: elements and outputs reference the same Dataset
+        ds1 = self.dataset_manager.create()
+        ds2 = self.dataset_manager.create()
+
+        el1 = self.hda_manager.create(name="el1", history=history, dataset=ds1)
+        el2 = self.hda_manager.create(name="el2", history=history, dataset=ds2)
+        element_identifiers = self.build_element_identifiers([el1, el2])
+        input_hdca = self.collection_manager.create(
+            self.trans, history, "paired input", "paired", element_identifiers=element_identifiers
+        )
+
+        # Outputs share dataset_id with elements (copy semantics)
+        out1 = self.hda_manager.create(name="out1", history=history, dataset=ds1)
+        out2 = self.hda_manager.create(name="out2", history=history, dataset=ds2)
+        self.trans.sa_session.flush()
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="__UNZIP_COLLECTION__")
+        self._link_job_input_hdca(job, input_hdca)
+        # Also link elements as individual inputs (some wrappers do this)
+        self._link_job_input_hda(job, el1, name="forward")
+        self._link_job_input_hda(job, el2, name="reverse")
+        self._link_job_output_hda(job, out1, name="forward")
+        self._link_job_output_hda(job, out2, name="reverse")
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        out1_enc = self._encode("d", out1.id)
+        out2_enc = self._encode("d", out2.id)
+
+        # Element inputs that resolve to outputs should be suppressed
+        # (collection input exists + resolved points to output → suppress)
+        input_edges = [e for e in graph.edges if e.target == tr_enc and "input" in e.type]
+        # Should only have collection_input, not dataset_input pointing to out1/out2
+        for e in input_edges:
+            assert e.source not in (out1_enc, out2_enc), f"False input edge from output: {e.source} → {e.target}"
+
+        # No self-loops
+        for e in graph.edges:
+            assert e.source != e.target
+
+    def test_single_element_collection(self):
+        """Collection with a single element behaves correctly."""
+        history, _ = self._create_history()
+        el = self._create_hda(history, name="single_element")
+        element_identifiers = self.build_element_identifiers([el])
+        hdca = self.collection_manager.create(
+            self.trans, history, "singleton", "list", element_identifiers=element_identifiers
+        )
+        output_hda = self._create_hda(history, name="output")
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="single_tool")
+        self._link_job_input_hdca(job, hdca)
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+
+        coll_enc = self._encode("c", hdca.id)
+        tr_enc = self._encode("r", tr.id)
+
+        # Collection input edge exists
+        input_edges = [e for e in graph.edges if e.target == tr_enc and e.type == "collection_input"]
+        assert len(input_edges) == 1
+        assert input_edges[0].source == coll_enc
+
+        # No self-loops
+        for e in graph.edges:
+            assert e.source != e.target
+
+    def test_large_collection_no_explosion(self):
+        """Collection with many elements does not cause graph explosion.
+
+        The graph should contain one collection node, not individual element nodes.
+        Node count must stay bounded regardless of element count.
+        """
+        history, _ = self._create_history()
+        # Create collection with 100 elements (using 100 to keep test fast;
+        # the principle is the same as 1000+)
+        elements = [self._create_hda(history, name=f"el_{i}") for i in range(100)]
+        element_identifiers = self.build_element_identifiers(elements)
+        hdca = self.collection_manager.create(
+            self.trans, history, "big list", "list", element_identifiers=element_identifiers
+        )
+        output_hda = self._create_hda(history, name="output")
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="big_tool")
+        self._link_job_input_hdca(job, hdca)
+        self._link_job_output_hda(job, output_hda)
+
+        graph = self._build_graph(history)
+
+        # Collection is one node, not 100
+        collection_nodes = [n for n in graph.nodes if n.type == "collection"]
+        assert len(collection_nodes) == 1
+
+        # Total nodes: 100 element HDAs (hidden, removed as elements) +
+        # 1 collection + 1 output + 1 tool_request = 3, but the element HDAs
+        # are visible top-level items too, so they may appear. The key invariant
+        # is that edge count stays bounded — one collection_input, not 100 dataset_inputs.
+        input_edges = [e for e in graph.edges if e.target == self._encode("r", tr.id) and "input" in e.type]
+        assert len(input_edges) == 1
+        assert input_edges[0].type == "collection_input"
+
+        # No self-loops
+        for e in graph.edges:
+            assert e.source != e.target
+
+    # ── Remaining validation tests ──
+
+    def test_multiple_copies_same_dataset(self):
+        """Multiple HDAs sharing the same dataset_id appear as distinct nodes.
+
+        Copy resolution only applies to execution artifacts outside scope.
+        When both copies are in scope, they remain separate nodes.
+        """
+        history, _ = self._create_history()
+        dataset = self.dataset_manager.create()
+        copy1 = self.hda_manager.create(name="copy_1", history=history, dataset=dataset)
+        copy2 = self.hda_manager.create(name="copy_2", history=history, dataset=dataset)
+        copy3 = self.hda_manager.create(name="copy_3", history=history, dataset=dataset)
+        self.trans.sa_session.flush()
+
+        graph = self._build_graph(history)
+
+        node_ids = {n.id for n in graph.nodes}
+        assert self._encode("d", copy1.id) in node_ids
+        assert self._encode("d", copy2.id) in node_ids
+        assert self._encode("d", copy3.id) in node_ids
+        assert len(graph.nodes) == 3
+
+    def test_n1_copied_hda_has_producer_edge(self):
+        """Rule N1: a copied HDA (no JobToOutputDatasetAssociation row of
+        its own) still gets a producer edge via ``Dataset.job_id``.
+
+        Mirrors the production invariant that ``Job.add_output_dataset``
+        sets ``Dataset.job_id`` on the underlying Dataset, which is then
+        shared between the original HDA and any copies.  A copy inherits
+        producer attribution through the shared Dataset.
+        """
+        history, _ = self._create_history()
+        # Original: create an HDA and link it as the named output of a job.
+        # The test helper mirrors production by also setting Dataset.job_id.
+        original = self._create_hda(history, name="original")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="producer_tool")
+        self._link_job_output_hda(job, original)
+
+        # Copy: a second HDA on the *same* Dataset, with NO
+        # JobToOutputDatasetAssociation row.  In the old builder (which
+        # looked up via that table) this HDA would have no producer edge.
+        copy = self.hda_manager.create(name="copy", history=history, dataset=original.dataset)
+        self.trans.sa_session.flush()
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        original_enc = self._encode("d", original.id)
+        copy_enc = self._encode("d", copy.id)
+
+        # Both the original AND the copy have producer edges from tr.
+        producer_edges = {
+            (e.source, e.target) for e in graph.edges if e.type == "dataset_output"
+        }
+        assert (tr_enc, original_enc) in producer_edges, "Original should have producer edge"
+        assert (tr_enc, copy_enc) in producer_edges, "Copy should have producer edge via Dataset.job_id (N1)"
+
+    def test_closure_resolves_hidden_element_input_to_parent_collection(self):
+        """Real-data bug fix: a tool consumes a hidden element HDA
+        directly via JobToInputDatasetAssociation (not via the
+        element-association table).  The element HDA is filtered out
+        by Rule N3, so closure must walk DCE → DC → HDCA via
+        HDCA.collection_id and surface the parent collection as the
+        user-visible input.
+
+        Without this, tools like Convert that operate on the 'forward'
+        half of a paired collection appear with no inputs at all.
+        """
+        history, _ = self._create_history()
+        # Create a paired collection with two element HDAs.  These
+        # element HDAs are hidden and visible-False (production
+        # behaviour for collection elements).
+        forward = self._create_hda(history, name="forward.fastq")
+        reverse = self._create_hda(history, name="reverse.fastq")
+        forward.visible = False
+        reverse.visible = False
+        element_identifiers = [
+            {"name": "forward", "src": "hda", "id": forward.id},
+            {"name": "reverse", "src": "hda", "id": reverse.id},
+        ]
+        paired = self.collection_manager.create(
+            self.trans, history, "paired", "paired", element_identifiers=element_identifiers
+        )
+        self.trans.sa_session.flush()
+
+        # Convert tool consumes the 'forward' element HDA directly.
+        out_hda = self._create_hda(history, name="converted")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="Convert")
+        self._link_job_input_hda(job, forward)
+        self._link_job_output_hda(job, out_hda)
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        # The tool_request must have an input edge — and it should be a
+        # collection_input edge to the parent paired collection, not a
+        # dataset_input edge to the hidden forward element (which N3
+        # filters out as not-top-level).
+        in_edges = [e for e in graph.edges if e.target == tr_enc]
+        assert len(in_edges) == 1, (
+            "Tool consuming hidden element HDA must have its parent collection "
+            "surfaced as a closure input"
+        )
+        edge = in_edges[0]
+        assert edge.type == "collection_input"
+        assert edge.source == self._encode("c", paired.id)
+
+    def test_jtoda_only_output_caught(self):
+        """Real-data bug fix: tools like Unzip claim existing datasets
+        as outputs via JobToOutputDatasetAssociation but do NOT update
+        Dataset.job_id.  The Rule N1 reverse query (Dataset.job_id)
+        misses these — only the JobToOutputDatasetAssociation pathway
+        finds them.
+
+        Without this, Unzip-like tools appear with no outputs at all.
+        """
+        history, _ = self._create_history()
+        # Original upload: an existing HDA whose Dataset.job_id points
+        # at a different (upload) job.
+        upload_job = self._create_job(tool_id="upload1")
+        original = self._create_hda(history, name="paired.fastq")
+        original.dataset.job_id = upload_job.id
+
+        # The unwrapped HDA: same Dataset (so Dataset.job_id == upload_job.id)
+        # but a different HDA in the same history.
+        unwrapped = self.hda_manager.create(name="unwrapped", history=history, dataset=original.dataset)
+        self.trans.sa_session.flush()
+
+        # The "Unzip" tool claims unwrapped as its output via the
+        # JobToOutputDatasetAssociation table only — without setting
+        # Dataset.job_id (since the dataset already had one).
+        tr = self._create_tool_request(history)
+        unzip_job = self._create_job(tool_request=tr, tool_id="__UNZIP_COLLECTION__")
+        self._link_job_input_hda(unzip_job, original)
+        # Manually create the JTODA row WITHOUT touching Dataset.job_id.
+        assoc = model.JobToOutputDatasetAssociation(name="forward", dataset=unwrapped)
+        assoc.job_id = unzip_job.id
+        self.trans.sa_session.add(assoc)
+        self.trans.sa_session.flush()
+        # Sanity check: Dataset.job_id is the upload job, NOT the unzip job.
+        assert unwrapped.dataset.job_id == upload_job.id
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        out_edges = [e for e in graph.edges if e.source == tr_enc and e.type == "dataset_output"]
+        unwrapped_enc = self._encode("d", unwrapped.id)
+        assert any(e.target == unwrapped_enc for e in out_edges), (
+            "Unzip-style tools claiming an existing HDA via JobToOutputDatasetAssociation "
+            "must produce an output edge even when Dataset.job_id points elsewhere"
+        )
+
+    def test_n2_jodca_only_hdca_has_producer_edge(self):
+        """Rule N2 branch (b): an HDCA with no ``job_id``, no implicit
+        collection chain, and no TRICA row — only a
+        ``JobToOutputDatasetCollectionAssociation`` row — must still
+        get a producer edge.
+
+        This is the most common production case for non-implicit
+        collection outputs (``Job.add_output_dataset_collection``).
+        Earlier versions of the builder missed it because the test
+        helper artificially set ``hdca.job_id`` and masked the gap.
+        """
+        history, _ = self._create_history()
+        hda = self._create_hda(history, name="el")
+        element_identifiers = self.build_element_identifiers([hda])
+        hdca = self.collection_manager.create(
+            self.trans, history, "out list", "list", element_identifiers=element_identifiers
+        )
+        # Verify production-mirroring helper does NOT set HDCA.job_id.
+        assert hdca.job_id is None
+
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="zip_tool")
+        self._link_job_input_hda(job, hda)
+        # The helper writes a JobToOutputDatasetCollectionAssociation
+        # but does not set HDCA.job_id (matches production).
+        self._link_job_output_hdca(job, hdca)
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        hdca_enc = self._encode("c", hdca.id)
+        producer_edges = {
+            (e.source, e.target) for e in graph.edges if e.type == "collection_output"
+        }
+        assert (tr_enc, hdca_enc) in producer_edges, (
+            "HDCA producer edge must come from JobToOutputDatasetCollectionAssociation "
+            "even when HDCA.job_id is None"
+        )
+
+    def test_n2_implicit_collection_has_producer_edge(self):
+        """Rule N2: an HDCA produced via an implicit collection (map-over
+        output, ``HDCA.implicit_collection_jobs_id`` set) gets a producer
+        edge via the ``ImplicitCollectionJobsJobAssociation`` UNION branch.
+
+        This case was silently broken in the old builder which only
+        looked at ``HDCA.job_id``.
+        """
+        history, _ = self._create_history()
+        # Build an implicit-collection map-over: input collection, element
+        # jobs, output collection with implicit_collection_jobs_id set.
+        in_el = self._create_hda(history, name="el_in")
+        out_el = self._create_hda(history, name="el_out")
+        element_identifiers_in = self.build_element_identifiers([in_el])
+        self.collection_manager.create(
+            self.trans, history, "input list", "list", element_identifiers=element_identifiers_in
+        )
+        element_identifiers_out = self.build_element_identifiers([out_el])
+        output_hdca = self.collection_manager.create(
+            self.trans, history, "output list", "list", element_identifiers=element_identifiers_out
+        )
+
+        # Wire the implicit-collection-jobs chain: ICJ + ICJJA + HDCA link.
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="map_tool")
+        self._link_job_input_hda(job, in_el)
+        self._link_job_output_hda(job, out_el)
+
+        icj = model.ImplicitCollectionJobs(populated_state="ok")
+        self.trans.sa_session.add(icj)
+        self.trans.sa_session.flush()
+        icja = model.ImplicitCollectionJobsJobAssociation()
+        icja.implicit_collection_jobs_id = icj.id
+        icja.job_id = job.id
+        icja.order_index = 0
+        self.trans.sa_session.add(icja)
+        output_hdca.implicit_collection_jobs_id = icj.id
+        self.trans.sa_session.flush()
+
+        graph = self._build_graph(history)
+
+        tr_enc = self._encode("r", tr.id)
+        hdca_enc = self._encode("c", output_hdca.id)
+
+        producer_edges = {
+            (e.source, e.target) for e in graph.edges if e.type == "collection_output"
+        }
+        assert (tr_enc, hdca_enc) in producer_edges, (
+            "Implicit output HDCA should have producer edge via ICJ path (N2)"
+        )
+
+    def test_n2_ambiguous_hdca_producer_has_node_but_no_edge(self):
+        """Rule N2 dedupe fallback: when an HDCA resolves to ≥2 distinct
+        producer tool_request_ids across the UNION branches, the builder
+        emits no producer edge, keeps the HDCA as a node, and increments
+        the internal ``_hdca_producer_ambiguity_count``.
+
+        This is the deliberately conservative behavior — we do not pick
+        an arbitrary winner at the response level.
+        """
+        from galaxy.managers.history_graph import HistoryGraphBuilder
+
+        history, _ = self._create_history()
+        in_hda = self._create_hda(history, name="input")
+
+        # Build an HDCA with TWO disagreeing producer attributions:
+        # (a) HDCA.job_id → tr_direct
+        # (b) HDCA.implicit_collection_jobs_id → ICJ → job_b → tr_implicit
+        # These resolve to different tool_request_ids → ambiguous.
+        el = self._create_hda(history, name="el")
+        element_identifiers = self.build_element_identifiers([el])
+        hdca = self.collection_manager.create(
+            self.trans, history, "ambiguous out", "list", element_identifiers=element_identifiers
+        )
+
+        tr_direct = self._create_tool_request(history)
+        job_direct = self._create_job(tool_request=tr_direct, tool_id="tool_direct")
+        self._link_job_input_hda(job_direct, in_hda)
+        hdca.job_id = job_direct.id  # direct branch
+
+        tr_implicit = self._create_tool_request(history)
+        job_implicit = self._create_job(tool_request=tr_implicit, tool_id="tool_implicit")
+        self._link_job_input_hda(job_implicit, in_hda)
+        icj = model.ImplicitCollectionJobs(populated_state="ok")
+        self.trans.sa_session.add(icj)
+        self.trans.sa_session.flush()
+        icja = model.ImplicitCollectionJobsJobAssociation()
+        icja.implicit_collection_jobs_id = icj.id
+        icja.job_id = job_implicit.id
+        icja.order_index = 0
+        self.trans.sa_session.add(icja)
+        hdca.implicit_collection_jobs_id = icj.id  # implicit branch
+        self.trans.sa_session.flush()
+
+        # Build via a fresh builder instance so we can inspect the
+        # internal debug counter after build().
+        builder = HistoryGraphBuilder(
+            sa_session=self.trans.sa_session,
+            security=self.app.security,
+            history_id=history.id,
+            limit=500,
+        )
+        graph = builder.build()
+
+        hdca_enc = self._encode("c", hdca.id)
+        node_ids = {n.id for n in graph.nodes}
+        assert hdca_enc in node_ids, "Ambiguous HDCA should still be a node"
+
+        # No producer edge for this HDCA.
+        producer_targets = {
+            e.target for e in graph.edges if e.type == "collection_output"
+        }
+        assert hdca_enc not in producer_targets, (
+            "Ambiguous HDCA must NOT get a producer edge (N2 fallback)"
+        )
+
+        # Internal debug counter recorded the ambiguity.
+        assert builder._hdca_producer_ambiguity_count >= 1, (
+            "Ambiguity counter should have incremented"
+        )
+
+    def test_seed_filter_issues_no_extra_queries(self):
+        """Stage 9 lock: ``_extract_subgraph`` operates only on the
+        already-materialized in-memory graph and must NOT trigger any
+        additional DB queries.
+
+        Approach: count SQL statements issued during ``build()`` via a
+        SQLAlchemy event listener.  Assert that the seeded run does not
+        issue MORE queries than the unseeded run (Stage 9 may not add
+        DB access — it may incidentally avoid one due to autoflush
+        ordering, which is fine).  Also assert the seeded result is a
+        subset of the unseeded result (proving it's a pure post-filter,
+        not a different construction path).
+        """
+        from sqlalchemy import event
+
+        history, _ = self._create_history()
+        # Build a small chain so there's something to filter.
+        chain = self._build_linear_chain(history, length=3)
+        # Seed on the middle dataset in the chain.
+        seed_hda = chain[1][0]
+        seed_enc = self._encode("d", seed_hda.id)
+
+        # Flush any pending state so neither build triggers an
+        # incidental autoflush during the measurement window.
+        self.trans.sa_session.flush()
+
+        engine = self.trans.sa_session.get_bind()
+
+        counter = {"n": 0}
+
+        def _count(_conn, _cursor, _statement, _parameters, _context, _executemany):
+            counter["n"] += 1
+
+        event.listen(engine, "before_cursor_execute", _count)
+        try:
+            self.trans.sa_session.flush()
+            counter["n"] = 0
+            unseeded = self._build_graph(history)
+            unseeded_count = counter["n"]
+            unseeded_ids = {n.id for n in unseeded.nodes}
+
+            self.trans.sa_session.flush()
+            counter["n"] = 0
+            seeded = self._build_graph(history, seed=seed_enc, depth=20)
+            seeded_count = counter["n"]
+            seeded_ids = {n.id for n in seeded.nodes}
+        finally:
+            event.remove(engine, "before_cursor_execute", _count)
+
+        # The Stage 9 lock requires that seeded never issues MORE queries
+        # than unseeded — _extract_subgraph must add zero DB access.
+        assert seeded_count <= unseeded_count, (
+            f"Seeded build issued {seeded_count} SQL statements, "
+            f"unseeded issued {unseeded_count}. Stage 9 must not trigger extra DB access."
+        )
+        assert seeded_ids.issubset(unseeded_ids), (
+            "Seeded result must be a subset of unseeded — seed is a pure post-filter"
+        )
+        assert seed_enc in seeded_ids, "Seed itself should be in the seeded result"
+
+    def test_closure_invariant_no_partial_executions(self):
+        """Closure invariant: every execution node in the graph has all
+        of its top-level inputs and outputs (in this history) present
+        as nodes, with the corresponding edges materialized.
+
+        Constructs a multi-tool history at the seed-window boundary so
+        that, without closure, several tool_requests would have missing
+        sides.  Asserts that EVERY tool_request in the response has a
+        complete neighborhood.
+        """
+        history, _ = self._create_history()
+        # 5-step chain: hda0 → tr0 → hda1 → tr1 → hda2 → tr2 → hda3 → tr3 → hda4 → tr4 → hda5
+        chain = self._build_linear_chain(history, length=5)
+
+        # Pick a small seed window in the middle of the chain.
+        middle_input_hid = chain[2][0].hid
+        graph = self._build_graph(history, older_than_hid=middle_input_hid + 1, newer_than_hid=middle_input_hid - 1)
+
+        node_ids = {n.id for n in graph.nodes}
+        tr_nodes = [n for n in graph.nodes if n.type == "tool_request"]
+        assert len(tr_nodes) >= 1, "Expected at least one tool_request via closure"
+
+        # For each tool_request in the graph, all its incident edges
+        # must reference items that are also nodes in the graph.
+        for tr_node in tr_nodes:
+            connected_items = {
+                e.source for e in graph.edges if e.target == tr_node.id
+            } | {
+                e.target for e in graph.edges if e.source == tr_node.id
+            }
+            for item_id in connected_items:
+                assert item_id in node_ids, (
+                    f"Tool_request {tr_node.id} has edge referencing missing node {item_id} — "
+                    "closure invariant violated"
+                )
+            assert len(connected_items) >= 2, (
+                f"Tool_request {tr_node.id} has only {len(connected_items)} connected items — "
+                "expected at least one input and one output after closure"
+            )
+
+    def test_closure_pulls_items_but_not_recursive_executions(self):
+        """Closure expands ITEMS only, never recursively pulls in new
+        execution nodes from those added items.
+
+        Build a longer chain so we can isolate a single seed item that
+        has its OWN producer + consumer in scope, and verify closure
+        does NOT bring in the producer/consumer of items further out.
+
+        chain: hda0 → tr0 → hda1 → tr1 → hda2 → tr2 → hda3 → tr3 → hda4
+        seed: only hda2 (via tight hid window)
+        Expected after closure:
+          - hda2 is in seed
+          - tr1 is producer of hda2 → in graph (sticky)
+          - tr2 is consumer of hda2 → in graph (non-sticky)
+          - closure pulls in hda1 (input to tr1) and hda3 (output of tr2)
+          - tr0 (producer of hda1) is NOT in graph — closure pulled in
+            hda1 as an item but did NOT recurse to its producer
+          - tr3 (consumer of hda3) is NOT in graph — same reason
+        """
+        history, _ = self._create_history()
+        chain = self._build_linear_chain(history, length=4)
+        # chain[i] = (input_hda_i, tr_i, output_hda_i)
+        # The output of step i is the input of step i+1
+        hda2 = chain[1][2]  # output of tr1, input of tr2
+        tr0 = chain[0][1]
+        tr1 = chain[1][1]
+        tr2 = chain[2][1]
+        tr3 = chain[3][1]
+
+        # Seed window holds hda2 only.  Use a generous limit so the
+        # closure cap (= limit) does not fire.
+        graph = self._build_graph(
+            history,
+            older_than_hid=hda2.hid + 1,
+            newer_than_hid=hda2.hid - 1,
+            limit=20,
+        )
+
+        tr_ids_in_graph = {n.id for n in graph.nodes if n.type == "tool_request"}
+        assert self._encode("r", tr1.id) in tr_ids_in_graph, "tr1 (producer of seed) must be present"
+        assert self._encode("r", tr2.id) in tr_ids_in_graph, "tr2 (consumer of seed) must be present"
+        assert self._encode("r", tr0.id) not in tr_ids_in_graph, (
+            "tr0 must NOT be present — closure pulled in hda1 as an item but must not "
+            "recursively pull in the producer of hda1"
+        )
+        assert self._encode("r", tr3.id) not in tr_ids_in_graph, (
+            "tr3 must NOT be present — closure pulled in hda3 as an item but must not "
+            "recursively pull in the consumer of hda3"
+        )
+        # Exactly the two tool_requests directly touching the seed.
+        assert len(tr_ids_in_graph) == 2
+
+        # Closure pulled in items beyond the single-item seed window.
+        assert graph.truncated.closure_items_added >= 2
+
+        # Closure cap did not fire (limit was generous).
+        assert graph.truncated.closure_capped is False
+
+    def test_closure_cap_removes_executions_not_items(self):
+        """Closure cap pruning removes executions, never items.
+
+        Constructs many consumer tool_requests on a single seed item,
+        each consuming/producing a unique extra item, so the closure
+        item count would explode.  With a tight closure cap, the
+        builder must:
+          - drop oldest non-sticky (consumer-only) trs first
+          - keep producer (sticky) trs
+          - report closure_capped=True
+        """
+        history, _ = self._create_history()
+        seed_hda = self._create_hda(history, name="seed")
+        # Producer of the seed item — sticky.
+        producer_tr = self._create_tool_request(history)
+        producer_job = self._create_job(tool_request=producer_tr, tool_id="producer")
+        producer_input = self._create_hda(history, name="producer_input")
+        self._link_job_input_hda(producer_job, producer_input)
+        self._link_job_output_hda(producer_job, seed_hda)
+
+        # Many consumer tool_requests, each with a unique output that
+        # closure would have to pull in.
+        consumer_trs = []
+        for i in range(5):
+            tr = self._create_tool_request(history)
+            job = self._create_job(tool_request=tr, tool_id=f"consumer_{i}")
+            self._link_job_input_hda(job, seed_hda)
+            extra_out = self._create_hda(history, name=f"consumer_{i}_out")
+            self._link_job_output_hda(job, extra_out)
+            consumer_trs.append(tr)
+
+        # Build with limit=1 → seed window holds one item, closure cap = 1.
+        # Closure would need to pull in producer_input + 5 consumer outputs = 6 items.
+        # Cap = 1 forces pruning of consumer trs (oldest first), keeping the
+        # sticky producer.
+        graph = self._build_graph(
+            history,
+            seed_scope=self._encode("d", seed_hda.id),
+            limit=1,
+        )
+
+        assert graph.truncated.closure_capped is True
+
+        kept_tr_ids = {n.id for n in graph.nodes if n.type == "tool_request"}
+        assert self._encode("r", producer_tr.id) in kept_tr_ids, (
+            "Sticky producer must survive closure cap pruning"
+        )
+
+        # At least some consumer trs were dropped.
+        kept_consumer_count = sum(
+            1 for tr in consumer_trs if self._encode("r", tr.id) in kept_tr_ids
+        )
+        assert kept_consumer_count < len(consumer_trs), (
+            "Some consumer tool_requests should have been pruned by the closure cap"
+        )
+
+        # Critical: every kept tool_request is structurally complete.
+        node_ids = {n.id for n in graph.nodes}
+        for tr_id in kept_tr_ids:
+            connected = {e.source for e in graph.edges if e.target == tr_id} | {
+                e.target for e in graph.edges if e.source == tr_id
+            }
+            for item in connected:
+                assert item in node_ids, (
+                    f"Closure cap pruning left tr {tr_id} pointing to missing item {item}"
+                )
+
+    def test_pagination_newer_than_hid(self):
+        """newer_than_hid selects only items with hid > N."""
+        history, _ = self._create_history()
+        hdas = [self._create_hda(history, name=f"ds_{i}") for i in range(6)]
+
+        # Get the middle item's hid as boundary
+        boundary_hid = hdas[2].hid
+
+        graph = self._build_graph(history, newer_than_hid=boundary_hid)
+
+        # Only items with hid > boundary_hid should be included
+        for n in graph.nodes:
+            assert n.hid is not None
+            assert n.hid > boundary_hid, f"Node hid {n.hid} should be > {boundary_hid}"
+        assert len(graph.nodes) == 3  # hdas[3], hdas[4], hdas[5]
+
+    def test_closure_completes_tool_requests_across_pagination(self):
+        """Closure rule under pagination: tool_requests crossing a
+        page boundary still appear with all their top-level inputs and
+        outputs.  The seed window stays unchanged
+        (oldest_hid_included/newest_hid_included describe the seed),
+        but closure expansion pulls in items outside the window.
+        """
+        history, _ = self._create_history()
+        input_hda = self._create_hda(history, name="input")
+        output_hda = self._create_hda(history, name="output")
+        tr = self._create_tool_request(history)
+        job = self._create_job(tool_request=tr, tool_id="boundary_tool")
+        self._link_job_input_hda(job, input_hda)
+        self._link_job_output_hda(job, output_hda)
+
+        # Full graph baseline: tool_request fully connected.
+        full = self._build_graph(history)
+        full_tr = [n for n in full.nodes if n.type == "tool_request"]
+        assert len(full_tr) == 1
+
+        # Page with only the older item (input).  Without closure the
+        # tool_request would be missing its output edge.  With closure
+        # the output item is pulled in.
+        graph = self._build_graph(history, older_than_hid=output_hda.hid)
+
+        tr_enc = self._encode("r", tr.id)
+        node_ids = {n.id for n in graph.nodes}
+        assert tr_enc in node_ids
+        assert self._encode("d", input_hda.id) in node_ids
+        assert self._encode("d", output_hda.id) in node_ids, (
+            "Output item should be pulled in by closure even though it is outside the seed window"
+        )
+
+        in_edges = [e for e in graph.edges if e.target == tr_enc and e.type == "dataset_input"]
+        out_edges = [e for e in graph.edges if e.source == tr_enc and e.type == "dataset_output"]
+        assert len(in_edges) == 1
+        assert len(out_edges) == 1
+
+        # oldest_hid_included still describes the SEED window (input only).
+        assert graph.truncated.newest_hid_included is not None
+        assert graph.truncated.newest_hid_included < output_hda.hid
+        assert graph.truncated.closure_items_added >= 1
+
+    def test_stability_new_items_shift_recent_window(self):
+        """Adding new items shifts the recent-overview window.
+
+        The most recent N items are selected. Adding a new item pushes
+        the oldest item out of the window when limit is reached.
+        """
+        history, _ = self._create_history()
+        original = [self._create_hda(history, name=f"ds_{i}") for i in range(5)]
+
+        # All 5 in scope
+        graph1 = self._build_graph(history, limit=5)
+        ids1 = {n.id for n in graph1.nodes}
+        assert len(ids1) == 5
+
+        # Add a new item — now 6 total, limit=5 means oldest drops out
+        new_hda = self._create_hda(history, name="ds_new")
+        graph2 = self._build_graph(history, limit=5)
+        ids2 = {n.id for n in graph2.nodes}
+        assert len(ids2) == 5
+
+        # The new item is in scope
+        assert self._encode("d", new_hda.id) in ids2
+        # The oldest original item is no longer in scope
+        assert self._encode("d", original[0].id) not in ids2
+        # The rest of the original items are still in scope
+        for hda in original[1:]:
+            assert self._encode("d", hda.id) in ids2
+
+    def test_stability_hid_window_does_not_mutate(self):
+        """A fixed hid-based window returns the same results even after new items are added."""
+        history, _ = self._create_history()
+        for i in range(5):
+            self._create_hda(history, name=f"ds_{i}")
+
+        # Take a snapshot with older_than_hid to define a fixed window
+        snapshot = self._build_graph(history, older_than_hid=4)
+        snapshot_ids = {n.id for n in snapshot.nodes}
+        snapshot_hids = sorted(n.hid for n in snapshot.nodes if n.hid is not None)
+
+        # Add new items to the history (higher hids)
+        for i in range(5, 10):
+            self._create_hda(history, name=f"ds_{i}")
+
+        # Same window query returns identical results
+        after = self._build_graph(history, older_than_hid=4)
+        after_ids = {n.id for n in after.nodes}
+        after_hids = sorted(n.hid for n in after.nodes if n.hid is not None)
+
+        assert snapshot_ids == after_ids
+        assert snapshot_hids == after_hids
+
+
+# ── Scalability / Boundedness Tests ──
+
+GRAPH_SCALE_HISTORY_SIZE = int(os.environ.get("GRAPH_SCALE_HISTORY_SIZE", 500))
+GRAPH_SCALE_CHAIN_LENGTH = int(os.environ.get("GRAPH_SCALE_CHAIN_LENGTH", 100))
+GRAPH_SCALE_COLLECTION_COUNT = int(os.environ.get("GRAPH_SCALE_COLLECTION_COUNT", 10))
+GRAPH_SCALE_COLLECTION_SIZE = int(os.environ.get("GRAPH_SCALE_COLLECTION_SIZE", 50))
+
+
+class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
+    """Scalability and boundedness tests for HistoryGraphBuilder.
+
+    These validate that the builder produces bounded, structurally correct output
+    on larger synthetic histories. They assert shape and boundedness, not timing.
+    Sizes are env-configurable: GRAPH_SCALE_HISTORY_SIZE, GRAPH_SCALE_CHAIN_LENGTH,
+    GRAPH_SCALE_COLLECTION_COUNT, GRAPH_SCALE_COLLECTION_SIZE.
+    """
+
+    def set_up_managers(self):
+        super().set_up_managers()
+        self.dataset_manager = self.app[DatasetManager]
+        self.hda_manager = self.app[HDAManager]
+        self.history_manager = self.app[HistoryManager]
+        self.collection_manager = self.app[DatasetCollectionManager]
+
+    def _build_graph(self, history, **kwargs):
+        builder = HistoryGraphBuilder(
+            sa_session=self.trans.sa_session,
+            security=self.app.security,
+            history_id=history.id,
+            **kwargs,
+        )
+        return builder.build()
+
+    def _encode(self, prefix, db_id):
+        return f"{prefix}{self.app.security.encode_id(db_id)}"
+
+    def _create_history(self):
+        user = self.user_manager.create(**_next_user_data())
+        self.trans.set_user(user)
+        return self.history_manager.create(name="scale_history", user=user), user
+
+    def _create_hda(self, history, name="ds", extension="txt"):
+        hda = self.hda_manager.create(name=name, history=history, dataset=self.dataset_manager.create())
+        hda.extension = extension
+        self.trans.sa_session.flush()
+        return hda
+
+    def _create_tool_source(self):
+        ts = model.ToolSource()
+        ts.hash = "abc123"
+        ts.source = {"xml": "<tool/>"}
+        ts.source_class = "XmlToolSource"
+        session = self.trans.sa_session
+        session.add(ts)
+        session.flush()
+        return ts
+
+    def _create_tool_request(self, history):
+        ts = self._create_tool_source()
+        tr = model.ToolRequest()
+        tr.tool_source_id = ts.id
+        tr.history_id = history.id
+        tr.request = {}
+        tr.state = "submitted"
+        session = self.trans.sa_session
+        session.add(tr)
+        session.flush()
+        return tr
+
+    def _create_job(self, tool_request, tool_id="test_tool"):
+        job = model.Job()
+        job.tool_id = tool_id
+        job.tool_version = "1.0"
+        job.tool_request_id = tool_request.id
+        session = self.trans.sa_session
+        session.add(job)
+        session.flush()
+        return job
+
+    def _link_job_input_hda(self, job, hda, name="input"):
+        assoc = model.JobToInputDatasetAssociation(name=name, dataset=hda)
+        assoc.job_id = job.id
+        self.trans.sa_session.add(assoc)
+        self.trans.sa_session.flush()
+
+    def _link_job_output_hda(self, job, hda, name="output"):
+        assoc = model.JobToOutputDatasetAssociation(name=name, dataset=hda)
+        assoc.job_id = job.id
+        self.trans.sa_session.add(assoc)
+        self.trans.sa_session.flush()
+
+    def _link_job_input_hdca(self, job, hdca, name="input"):
+        assoc = model.JobToInputDatasetCollectionAssociation(name=name, dataset_collection=hdca)
+        assoc.job_id = job.id
+        self.trans.sa_session.add(assoc)
+        self.trans.sa_session.flush()
+
+    def _link_job_output_hdca(self, job, hdca, name="output"):
+        assoc = model.JobToOutputDatasetCollectionAssociation(name=name, dataset_collection_instance=hdca)
+        assoc.job_id = job.id
+        self.trans.sa_session.add(assoc)
+        self.trans.sa_session.flush()
+
+    def _link_implicit_collection(self, tool_request, hdca):
+        assoc = model.ToolRequestImplicitCollectionAssociation()
+        assoc.tool_request_id = tool_request.id
+        assoc.dataset_collection_id = hdca.id
+        assoc.output_name = "output"
+        self.trans.sa_session.add(assoc)
+        self.trans.sa_session.flush()
+
+    # ── Test cases ──
+
+    def test_large_standalone_history(self):
+        """N standalone HDAs with bounded limit.
+
+        Assert: node count = min(N, limit), no edges, scope metadata valid.
+        """
+        n = GRAPH_SCALE_HISTORY_SIZE
+        limit = 200
+        history, _ = self._create_history()
+        for i in range(n):
+            self._create_hda(history, name=f"ds_{i}")
+
+        graph = self._build_graph(history, limit=limit)
+
+        assert len(graph.nodes) == min(n, limit)
+        assert len(graph.edges) == 0
+        assert graph.truncated.item_count_capped == (n > limit)
+        assert graph.truncated.oldest_hid_included is not None
+        assert graph.truncated.newest_hid_included is not None
+        assert graph.truncated.oldest_hid_included <= graph.truncated.newest_hid_included
+
+    def test_deep_linear_chain(self):
+        """N-step linear chain: A→tr→B→tr→C→...
+
+        Assert: bounded by limit, edges ≤ 2× representable TRs for this
+        linear shape (each TR has exactly one dataset_input + one dataset_output).
+        """
+        n = GRAPH_SCALE_CHAIN_LENGTH
+        limit = 50
+        history, _ = self._create_history()
+
+        prev = self._create_hda(history, name="input_0")
+        for i in range(n):
+            tr = self._create_tool_request(history)
+            job = self._create_job(tr, tool_id=f"tool_{i}")
+            self._link_job_input_hda(job, prev)
+            out = self._create_hda(history, name=f"output_{i}")
+            self._link_job_output_hda(job, out)
+            prev = out
+
+        graph = self._build_graph(history, limit=limit)
+
+        # Items bounded by limit
+        item_nodes = [nd for nd in graph.nodes if nd.type != "tool_request"]
+        assert len(item_nodes) <= limit
+
+        # For linear chain: each full TR has 2 edges, partial TRs have 1
+        tr_nodes = [nd for nd in graph.nodes if nd.type == "tool_request"]
+
+        # Each TR has at least one edge
+        for tr_node in tr_nodes:
+            tr_edges = [e for e in graph.edges if e.target == tr_node.id or e.source == tr_node.id]
+            assert len(tr_edges) >= 1
+
+    def test_collection_heavy_map_over(self):
+        """M collections × K elements each, with map-over tool execution.
+
+        Assert: no element-level dataset explosion, collection-level edges
+        present, hidden element HDAs suppressed as nodes.
+        """
+        m = GRAPH_SCALE_COLLECTION_COUNT
+        k = GRAPH_SCALE_COLLECTION_SIZE
+        history, _ = self._create_history()
+        total_hidden_elements = 0
+
+        for coll_idx in range(m):
+            # Create elements (hidden — simulate Galaxy's map-over behavior)
+            elements = []
+            for el_idx in range(k):
+                hda = self._create_hda(history, name=f"el_{coll_idx}_{el_idx}")
+                hda.visible = False
+                elements.append(hda)
+            self.trans.sa_session.flush()
+            total_hidden_elements += len(elements)
+
+            element_identifiers = self.build_element_identifiers(elements)
+            input_hdca = self.collection_manager.create(
+                self.trans,
+                history,
+                f"input_coll_{coll_idx}",
+                "list",
+                element_identifiers=element_identifiers,
+            )
+
+            # Output collection (implicit, from map-over)
+            out_elements = []
+            for el_idx in range(k):
+                hda = self._create_hda(history, name=f"out_{coll_idx}_{el_idx}")
+                hda.visible = False
+                out_elements.append(hda)
+            self.trans.sa_session.flush()
+            total_hidden_elements += len(out_elements)
+
+            out_identifiers = self.build_element_identifiers(out_elements)
+            output_hdca = self.collection_manager.create(
+                self.trans,
+                history,
+                f"output_coll_{coll_idx}",
+                "list",
+                element_identifiers=out_identifiers,
+            )
+
+            tr = self._create_tool_request(history)
+            job = self._create_job(tr, tool_id=f"map_tool_{coll_idx}")
+            self._link_job_input_hdca(job, input_hdca)
+            # Link element-level inputs (map-over pattern)
+            for el in elements:
+                self._link_job_input_hda(job, el)
+            # Link element-level outputs
+            for el in out_elements:
+                self._link_job_output_hda(job, el)
+            self._link_implicit_collection(tr, output_hdca)
+
+        graph = self._build_graph(history)
+
+        # Collection nodes bounded by 2*m (input + output collections)
+        coll_nodes = [nd for nd in graph.nodes if nd.type == "collection"]
+        assert len(coll_nodes) <= 2 * m
+
+        # No element-level dataset explosion: dataset nodes must be far fewer
+        # than the total hidden elements created (m*k*2)
+        dataset_nodes = [nd for nd in graph.nodes if nd.type == "dataset"]
+        assert (
+            len(dataset_nodes) < total_hidden_elements
+        ), f"Element explosion: {len(dataset_nodes)} dataset nodes from {total_hidden_elements} hidden elements"
+
+        # Collection-level edges present on representable TRs
+        tr_nodes = [nd for nd in graph.nodes if nd.type == "tool_request"]
+        for tr_node in tr_nodes:
+            input_edges = [e for e in graph.edges if e.target == tr_node.id]
+            output_edges = [e for e in graph.edges if e.source == tr_node.id]
+            for e in input_edges:
+                assert e.type == "collection_input", f"Expected collection_input, got {e.type}"
+            for e in output_edges:
+                assert e.type == "collection_output", f"Expected collection_output, got {e.type}"
+
+        # Total edge count bounded: not m*k element edges
+        assert len(graph.edges) <= 2 * len(tr_nodes)
+
+    def test_pagination_non_overlapping_windows(self):
+        """Two consecutive pages on a large history.
+
+        Assert: no overlap, deterministic ordering, expected hid ranges.
+        """
+        n = GRAPH_SCALE_HISTORY_SIZE
+        limit = n // 2
+        history, _ = self._create_history()
+        for i in range(n):
+            self._create_hda(history, name=f"ds_{i}")
+
+        # Page 1: most recent
+        page1 = self._build_graph(history, limit=limit)
+        page1_ids = {nd.id for nd in page1.nodes}
+        page1_hids = sorted(nd.hid for nd in page1.nodes if nd.hid is not None)
+
+        assert len(page1.nodes) == limit
+        assert page1.truncated.item_count_capped is True
+        oldest_hid_p1 = page1.truncated.oldest_hid_included
+
+        # Page 2: older items
+        page2 = self._build_graph(history, limit=limit, older_than_hid=oldest_hid_p1)
+        page2_ids = {nd.id for nd in page2.nodes}
+        page2_hids = sorted(nd.hid for nd in page2.nodes if nd.hid is not None)
+
+        # No overlap
+        assert len(page1_ids & page2_ids) == 0, "Pages must not overlap"
+
+        # Deterministic ordering: page1 has higher hids than page2
+        if page1_hids and page2_hids:
+            assert min(page1_hids) > max(page2_hids), "Page 1 should contain newer items than page 2"
+
+        # Expected hid ranges
+        assert page1.truncated.newest_hid_included >= page1.truncated.oldest_hid_included
+        assert page2.truncated.newest_hid_included >= page2.truncated.oldest_hid_included
+
+    def test_seed_scope_on_older_item(self):
+        """seed_scope on an early item in a large history.
+
+        Assert: seed item in scope, response bounded, scope metadata valid.
+        """
+        n = GRAPH_SCALE_HISTORY_SIZE
+        limit = 50
+        history, _ = self._create_history()
+        hdas = []
+        for i in range(n):
+            hdas.append(self._create_hda(history, name=f"ds_{i}"))
+
+        # Pick an early item (10th from the beginning)
+        early = hdas[9]
+        seed_scope = self._encode("d", early.id)
+
+        graph = self._build_graph(history, seed_scope=seed_scope, limit=limit)
+
+        # Seed item must be in scope
+        node_ids = {nd.id for nd in graph.nodes}
+        assert seed_scope in node_ids
+
+        # Response bounded
+        assert len(graph.nodes) <= limit
+
+        # Scope metadata valid
+        assert graph.truncated.scope_type == "seed_centered"
+        assert graph.truncated.oldest_hid_included is not None
+        assert graph.truncated.newest_hid_included is not None
+        assert graph.truncated.oldest_hid_included <= early.hid <= graph.truncated.newest_hid_included
+
+    def test_many_tool_requests_cap_enforced(self):
+        """Fan-out: each item connects to 3 TRs, exceeding the secondary TR cap.
+
+        The TR cap is limit × 2. With N items each connecting to 3 TRs,
+        discovered TRs = 3N > 2N = cap. Outputs are deleted so only the
+        original items are in scope, ensuring all fan-out TRs are discovered
+        from the input associations.
+        """
+        n_items = 100
+        history, _ = self._create_history()
+
+        # Create N visible items, each as input to 3 TRs
+        hdas = [self._create_hda(history, name=f"item_{i}") for i in range(n_items)]
+        for hda in hdas:
+            for j in range(3):
+                tr = self._create_tool_request(history)
+                job = self._create_job(tr, tool_id=f"fan_{j}")
+                self._link_job_input_hda(job, hda)
+                out = self._create_hda(history, name="fanout_out")
+                out.deleted = True  # Keep out of scope
+                self._link_job_output_hda(job, out)
+        self.trans.sa_session.flush()
+
+        # limit = n_items: all original items in scope.
+        # Discovered TRs = 300 (3 per item). Cap = 100 × 2 = 200. Triggers.
+        graph = self._build_graph(history, limit=n_items)
+
+        # TR cap enforced
+        tr_nodes = [nd for nd in graph.nodes if nd.type == "tool_request"]
+        assert len(tr_nodes) <= n_items * 2
+
+        # Secondary TR cap reported
+        assert graph.truncated.consumer_execution_capped is True
+
+    def test_recent_overview_shift_after_append(self):
+        """Recent overview shifts predictably when new items are appended.
+
+        Create a history near the limit, add newer items, verify the window
+        shifts and oldest items drop out.
+        """
+        limit = 50
+        history, _ = self._create_history()
+        original = []
+        for i in range(limit):
+            original.append(self._create_hda(history, name=f"ds_{i}"))
+
+        before = self._build_graph(history, limit=limit)
+        assert len(before.nodes) == limit
+        assert before.truncated.item_count_capped is False
+
+        # Add 10 newer items — pushes 10 oldest out
+        added = 10
+        for i in range(added):
+            self._create_hda(history, name=f"new_{i}")
+
+        after = self._build_graph(history, limit=limit)
+        assert len(after.nodes) == limit
+        assert after.truncated.item_count_capped is True
+
+        after_ids = {nd.id for nd in after.nodes}
+        # Oldest originals should be gone
+        for hda in original[:added]:
+            assert self._encode("d", hda.id) not in after_ids
+        # Newest originals should remain
+        for hda in original[added:]:
+            assert self._encode("d", hda.id) in after_ids
+
+    def test_large_hidden_element_suppression(self):
+        """Many hidden element HDAs do not become nodes.
+
+        Collection with many hidden elements: all suppressed, only the
+        collection node appears.
+        """
+        k = GRAPH_SCALE_COLLECTION_SIZE * 2  # double size for stress
+        history, _ = self._create_history()
+
+        elements = []
+        for i in range(k):
+            hda = self._create_hda(history, name=f"hidden_el_{i}")
+            hda.visible = False
+            elements.append(hda)
+        self.trans.sa_session.flush()
+
+        element_identifiers = self.build_element_identifiers(elements)
+        self.collection_manager.create(
+            self.trans,
+            history,
+            "big hidden list",
+            "list",
+            element_identifiers=element_identifiers,
+        )
+
+        graph = self._build_graph(history)
+
+        # No hidden element HDAs as nodes
+        dataset_nodes = [nd for nd in graph.nodes if nd.type == "dataset"]
+        assert len(dataset_nodes) == 0, f"Expected 0 dataset nodes (all hidden elements), got {len(dataset_nodes)}"
+
+        # Collection is present
+        coll_nodes = [nd for nd in graph.nodes if nd.type == "collection"]
+        assert len(coll_nodes) == 1

From b09a46ccb874f0411f2d068aad7b570ca6c128f7 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:31:23 +0300
Subject: [PATCH 05/28] Add generic graph view, node, edge, and zoom
 components.

---
 client/src/components/Graph/GraphEdges.vue  |  89 ++++++++++
 client/src/components/Graph/GraphNode.vue   | 114 ++++++++++++
 client/src/components/Graph/GraphView.vue   | 181 ++++++++++++++++++++
 client/src/components/Graph/ZoomControl.vue |  73 ++++++++
 client/src/components/Graph/types.ts        |  48 ++++++
 5 files changed, 505 insertions(+)
 create mode 100644 client/src/components/Graph/GraphEdges.vue
 create mode 100644 client/src/components/Graph/GraphNode.vue
 create mode 100644 client/src/components/Graph/GraphView.vue
 create mode 100644 client/src/components/Graph/ZoomControl.vue
 create mode 100644 client/src/components/Graph/types.ts

diff --git a/client/src/components/Graph/GraphEdges.vue b/client/src/components/Graph/GraphEdges.vue
new file mode 100644
index 00000000000..e3480b3559d
--- /dev/null
+++ b/client/src/components/Graph/GraphEdges.vue
@@ -0,0 +1,89 @@
+<script setup lang="ts">
+import { curveBasisPath, orthogonalPath } from "@/utils/connectionPath";
+
+import type { EdgeStyle, GraphEdge } from "./types";
+
+interface Props {
+    edges: GraphEdge[];
+    selectedNodeId?: string | null;
+    width: number;
+    height: number;
+    edgeStyle?: EdgeStyle;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+    selectedNodeId: null,
+    edgeStyle: "orthogonal",
+});
+
+/** Ribbon margin for collection edges — matches workflow editor's ribbonMargin */
+const RIBBON_MARGIN = 4;
+const RIBBON_OFFSETS = [-2 * RIBBON_MARGIN, -1 * RIBBON_MARGIN, 0, 1 * RIBBON_MARGIN, 2 * RIBBON_MARGIN];
+
+function makePath(points: { x: number; y: number }[]): string {
+    if (props.edgeStyle === "curved") {
+        return curveBasisPath(points.map((p) => [p.x, p.y] as [number, number]));
+    }
+    return orthogonalPath(points);
+}
+
+/** For a single (non-collection) edge, return one path string */
+function edgePaths(edge: GraphEdge): string[] {
+    if (!edge.isCollection || edge.points.length < 2) {
+        return [makePath(edge.points)];
+    }
+    // Collection ribbon: offset each path perpendicular to the edge direction.
+    // For orthogonal/curved layouts the edges run mostly left-to-right,
+    // so vertical offsets produce the ribbon effect.
+    return RIBBON_OFFSETS.map((offset) => {
+        const offsetPoints = edge.points.map((p) => ({ x: p.x, y: p.y + offset }));
+        return makePath(offsetPoints);
+    });
+}
+
+function edgeClass(edge: GraphEdge): Record<string, boolean> {
+    const isConnected =
+        !props.selectedNodeId || edge.source === props.selectedNodeId || edge.target === props.selectedNodeId;
+    return {
+        [edge.cssClass ?? "edge-default"]: true,
+        "edge-dimmed": !isConnected,
+        "edge-collection": !!edge.isCollection,
+    };
+}
+</script>
+
+<template>
+    <svg class="graph-edges" :width="width" :height="height">
+        <template v-for="edge in edges">
+            <path
+                v-for="(path, idx) in edgePaths(edge)"
+                :key="`${edge.id}-${idx}`"
+                :d="path"
+                :class="edgeClass(edge)"
+                fill="none" />
+        </template>
+    </svg>
+</template>
+
+<style lang="scss" scoped>
+@import "@/style/scss/theme/blue.scss";
+
+.graph-edges {
+    position: absolute;
+    top: 0;
+    left: 0;
+    pointer-events: none;
+    overflow: visible;
+    z-index: 0;
+}
+
+path {
+    stroke-width: 2;
+    stroke: $brand-primary;
+    transition: opacity 0.2s ease;
+}
+
+.edge-dimmed {
+    opacity: 0.3;
+}
+</style>
diff --git a/client/src/components/Graph/GraphNode.vue b/client/src/components/Graph/GraphNode.vue
new file mode 100644
index 00000000000..111bd2d7670
--- /dev/null
+++ b/client/src/components/Graph/GraphNode.vue
@@ -0,0 +1,114 @@
+<script setup lang="ts">
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { computed } from "vue";
+
+import type { GraphNode } from "./types";
+
+interface Props {
+    node: GraphNode;
+    selected: boolean;
+}
+
+const props = defineProps<Props>();
+const emit = defineEmits<{ (e: "select", nodeId: string): void }>();
+
+const nodeStyle = computed(() => ({
+    left: `${props.node.x}px`,
+    top: `${props.node.y}px`,
+    width: `${props.node.width}px`,
+}));
+
+const hasInputs = computed(() => props.node.inputs && props.node.inputs.length > 0);
+const hasOutputs = computed(() => props.node.outputs && props.node.outputs.length > 0);
+const hasPorts = computed(() => hasInputs.value || hasOutputs.value);
+const showRule = computed(() => hasInputs.value && hasOutputs.value);
+const showDataBody = computed(() => !hasPorts.value && (props.node.badge || props.node.data?.stateText));
+const iconSpin = computed(() => Boolean(props.node.data?.stateSpin));
+</script>
+
+<template>
+    <div
+        class="graph-node card"
+        :class="[node.cssClass, { 'node-highlight': selected }]"
+        :style="nodeStyle"
+        @click.stop="emit('select', node.id)">
+        <div class="graph-node-header card-header unselectable py-1 px-2" :data-state="node.data?.state ?? undefined">
+            <FontAwesomeIcon :icon="node.icon" class="graph-node-icon mr-1" :spin="iconSpin" />
+            <span class="graph-node-label" :title="node.label">{{ node.label }}</span>
+            <span v-if="hasPorts && node.badge" class="badge badge-light ml-auto">{{ node.badge }}</span>
+        </div>
+        <div v-if="showDataBody" class="card-body p-0 mx-2 my-1">
+            <span v-if="node.badge" class="badge badge-secondary">{{ node.badge }}</span>
+            <div v-if="node.data?.stateText" class="node-state-text">{{ node.data.stateText }}</div>
+        </div>
+        <div v-if="hasPorts" class="node-body card-body p-0 mx-2">
+            <div v-for="input in node.inputs" :key="`in-${input.name}`" class="form-row dataRow input-data-row">
+                <span class="node-port-label">{{ input.label }}</span>
+            </div>
+            <div v-if="showRule" class="rule" />
+            <div v-for="output in node.outputs" :key="`out-${output.name}`" class="form-row dataRow output-data-row">
+                <span class="node-port-label">{{ output.label }}</span>
+            </div>
+        </div>
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "@/style/scss/theme/blue.scss";
+
+.graph-node {
+    position: absolute;
+    cursor: pointer;
+    user-select: none;
+    border: solid $brand-primary 1px;
+    transition:
+        border-color 0.15s,
+        box-shadow 0.15s,
+        opacity 0.2s ease;
+}
+
+.node-highlight {
+    z-index: 1001;
+    border: solid $white 1px;
+    box-shadow: 0 0 0 3px $brand-primary;
+}
+
+.graph-node-header {
+    font-size: $font-size-base;
+}
+
+.graph-node-label {
+    font-weight: 500;
+    word-break: break-word;
+}
+
+.node-body {
+    font-size: $h6-font-size;
+}
+
+.node-state-text {
+    font-size: $h6-font-size;
+    color: $text-muted;
+    padding: 2px 0;
+}
+
+.form-row {
+    padding: 1px 0;
+}
+
+.output-data-row {
+    text-align: right;
+}
+
+.node-port-label {
+    color: $text-color;
+    padding: 0 2px;
+}
+
+.rule {
+    height: 0;
+    border: none;
+    border-bottom: dotted $brand-primary 1px;
+    margin: 0;
+}
+</style>
diff --git a/client/src/components/Graph/GraphView.vue b/client/src/components/Graph/GraphView.vue
new file mode 100644
index 00000000000..8d23b3649a0
--- /dev/null
+++ b/client/src/components/Graph/GraphView.vue
@@ -0,0 +1,181 @@
+<script setup lang="ts">
+import { useElementBounding } from "@vueuse/core";
+import { computed, nextTick, type Ref, ref, watch } from "vue";
+
+import { useD3Zoom } from "@/composables/d3Zoom";
+import { useViewportBoundingBox } from "@/composables/viewportBoundingBox";
+import { maxZoom, minZoom } from "@/utils/zoomLevels";
+
+import type { EdgeStyle, GraphLayout, GraphNode } from "./types";
+
+import GraphEdges from "./GraphEdges.vue";
+import GraphNodeComponent from "./GraphNode.vue";
+import ZoomControl from "./ZoomControl.vue";
+
+interface Props {
+    layout: GraphLayout | null;
+    focusNodeId?: string | null;
+    edgeStyle?: EdgeStyle;
+    showZoomControls?: boolean;
+    showMinimap?: boolean;
+    /** Minimap component — injected by consumer to avoid domain coupling */
+    minimapComponent?: object | null;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+    focusNodeId: null,
+    edgeStyle: "orthogonal",
+    showZoomControls: true,
+    showMinimap: true,
+    minimapComponent: null,
+});
+
+const emit = defineEmits<{ (e: "nodeSelected", node: GraphNode | null): void }>();
+
+const selectedNodeId = ref<string | null>(null);
+
+// Separate ref for the zoom level displayed in ZoomControl.
+// Set explicitly to snapped values — avoids floating point drift from d3.
+const scale = ref(1);
+
+// d3 zoom is attached to the inner canvas-container, NOT the outer wrapper.
+// This keeps ZoomControl and minimap outside the d3 event target.
+const canvasContainer: Ref<HTMLElement | null> = ref(null);
+const { transform, setZoom, panBy, moveTo } = useD3Zoom(1, minZoom, maxZoom, canvasContainer, { x: 50, y: 50 });
+
+// Element bounding for viewport computation (needed by minimap)
+const elementBounding = useElementBounding(canvasContainer, { windowResize: false, windowScroll: false });
+
+// Viewport bounding box in content coordinates
+const { viewportBoundingBox } = useViewportBoundingBox(elementBounding, scale, transform);
+
+// Sync scale ref from d3 zoom events (for scroll-wheel zoom)
+watch(
+    () => transform.value.k,
+    (k) => {
+        scale.value = k;
+    },
+);
+
+function onZoom(zoomLevel: number) {
+    setZoom(zoomLevel);
+}
+
+const canvasStyle = computed(() => ({
+    transform: `translate(${transform.value.x}px, ${transform.value.y}px) scale(${transform.value.k})`,
+}));
+
+function onNodeSelect(nodeId: string) {
+    if (selectedNodeId.value === nodeId) {
+        selectedNodeId.value = null;
+        emit("nodeSelected", null);
+    } else {
+        selectedNodeId.value = nodeId;
+        const node = props.layout?.nodes.find((n) => n.id === nodeId) ?? null;
+        emit("nodeSelected", node);
+    }
+}
+
+// Canvas background click deselects
+const mouseMovementThreshold = 9;
+let pointerDownPos: { x: number; y: number } | null = null;
+
+function onPointerDown(e: PointerEvent) {
+    pointerDownPos = { x: e.clientX, y: e.clientY };
+}
+
+function onPointerUp(e: PointerEvent) {
+    if (!pointerDownPos) {
+        return;
+    }
+    const dx = Math.abs(e.clientX - pointerDownPos.x);
+    const dy = Math.abs(e.clientY - pointerDownPos.y);
+    pointerDownPos = null;
+    const clickedOnNode = !!(e.target as HTMLElement).closest(".graph-node");
+    if (dx + dy <= mouseMovementThreshold && !clickedOnNode) {
+        selectedNodeId.value = null;
+        emit("nodeSelected", null);
+    }
+}
+
+// Center on focus node or bounding box after layout
+watch(
+    () => props.layout,
+    async (newLayout) => {
+        if (!newLayout) {
+            return;
+        }
+        await nextTick();
+
+        if (props.focusNodeId) {
+            const focusNode = newLayout.nodes.find((n) => n.id === props.focusNodeId);
+            if (focusNode) {
+                moveTo({ x: focusNode.x + focusNode.width / 2, y: focusNode.y + focusNode.height / 2 });
+                return;
+            }
+        }
+
+        if (newLayout.nodes.length > 0) {
+            moveTo({ x: newLayout.width / 2, y: newLayout.height / 2 });
+        }
+    },
+);
+</script>
+
+<template>
+    <div class="graph-canvas rounded">
+        <ZoomControl v-if="showZoomControls" :zoom-level="scale" @onZoom="onZoom" />
+        <div ref="canvasContainer" class="canvas-container" @pointerdown="onPointerDown" @pointerup="onPointerUp">
+            <div v-if="layout" class="graph-node-area" :style="canvasStyle">
+                <GraphEdges
+                    :edges="layout.edges"
+                    :selected-node-id="selectedNodeId"
+                    :width="layout.width + 200"
+                    :height="layout.height + 200"
+                    :edge-style="edgeStyle" />
+                <GraphNodeComponent
+                    v-for="node in layout.nodes"
+                    :key="node.id"
+                    :node="node"
+                    :selected="node.id === selectedNodeId"
+                    @select="onNodeSelect" />
+            </div>
+        </div>
+        <component
+            :is="minimapComponent"
+            v-if="showMinimap && minimapComponent && layout"
+            :layout="layout"
+            :viewport-bounding-box="viewportBoundingBox"
+            :selected-node-id="selectedNodeId"
+            :parent-right="elementBounding.right.value"
+            :parent-bottom="elementBounding.bottom.value"
+            @panBy="panBy"
+            @moveTo="moveTo" />
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "@/style/scss/theme/blue.scss";
+
+.graph-canvas {
+    flex: 1;
+    width: 100%;
+    position: relative;
+    overflow: hidden;
+}
+
+.canvas-container {
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+    position: relative;
+    background: $white;
+}
+
+.graph-node-area {
+    position: absolute;
+    top: 0;
+    left: 0;
+    transform-origin: 0 0;
+}
+</style>
diff --git a/client/src/components/Graph/ZoomControl.vue b/client/src/components/Graph/ZoomControl.vue
new file mode 100644
index 00000000000..4dc9669f9d6
--- /dev/null
+++ b/client/src/components/Graph/ZoomControl.vue
@@ -0,0 +1,73 @@
+<script setup lang="ts">
+import { computed } from "vue";
+
+import { getZoomInLevel, getZoomOutLevel, isMaxZoom, isMinZoom } from "@/utils/zoomLevels";
+
+const props = defineProps({
+    zoomLevel: { type: Number, default: 1 },
+});
+
+const emit = defineEmits<{
+    (e: "onZoom", zoom: number): void;
+}>();
+
+const zoomDefault = 1;
+const zoomPercentage = computed(() => Math.round(props.zoomLevel * 100));
+
+function onZoomIn() {
+    emit("onZoom", getZoomInLevel(props.zoomLevel));
+}
+
+function onZoomOut() {
+    emit("onZoom", getZoomOutLevel(props.zoomLevel));
+}
+
+function onZoomReset() {
+    emit("onZoom", zoomDefault);
+}
+</script>
+
+<template>
+    <span class="zoom-control float-right btn-group-horizontal">
+        <b-button
+            :disabled="isMinZoom(props.zoomLevel)"
+            role="button"
+            class="fa fa-minus"
+            title="Zoom Out"
+            size="sm"
+            aria-label="Zoom Out"
+            @click="onZoomOut" />
+        <b-button
+            v-b-tooltip.hover
+            role="button"
+            class="zoom-reset"
+            variant="light"
+            title="Reset Zoom Level"
+            size="sm"
+            aria-label="Reset Zoom Level"
+            @click="onZoomReset">
+            {{ zoomPercentage }}%
+        </b-button>
+        <b-button
+            :disabled="isMaxZoom(props.zoomLevel)"
+            role="button"
+            class="fa fa-plus"
+            title="Zoom In"
+            size="sm"
+            aria-label="Zoom In"
+            @click="onZoomIn" />
+    </span>
+</template>
+
+<style scoped>
+.zoom-reset {
+    width: 4rem;
+}
+.zoom-control {
+    position: absolute;
+    left: 1rem;
+    bottom: 1rem;
+    cursor: pointer;
+    z-index: 2000;
+}
+</style>
diff --git a/client/src/components/Graph/types.ts b/client/src/components/Graph/types.ts
new file mode 100644
index 00000000000..e35af12cc18
--- /dev/null
+++ b/client/src/components/Graph/types.ts
@@ -0,0 +1,48 @@
+import type { IconDefinition } from "@fortawesome/free-solid-svg-icons";
+
+/** A labeled port on a graph node (input or output connector) */
+export interface GraphNodePort {
+    name: string;
+    label: string;
+}
+
+/** A positioned node after layout */
+export interface GraphNode {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    label: string;
+    icon: IconDefinition;
+    badge?: string | null;
+    cssClass?: string;
+    /** Input ports displayed in the node body */
+    inputs?: GraphNodePort[];
+    /** Output ports displayed in the node body */
+    outputs?: GraphNodePort[];
+    /** Arbitrary domain data attached by the mapper */
+    data?: Record<string, unknown>;
+}
+
+/** A positioned edge after layout, with routed points */
+export interface GraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    cssClass?: string;
+    /** Render as a collection ribbon (multiple parallel lines) */
+    isCollection?: boolean;
+    points: { x: number; y: number }[];
+}
+
+/** Edge rendering style */
+export type EdgeStyle = "orthogonal" | "curved";
+
+/** Complete layout result ready for rendering */
+export interface GraphLayout {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    width: number;
+    height: number;
+}

From d2374a25ed09855b8a3616ccf1a810fda91ce10a Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:31:26 +0300
Subject: [PATCH 06/28] Add history graph views, data loader, layout, and
 mapper.

---
 .../History/Content/model/states.ts           |   2 +-
 .../History/Graph/HistoryGraphDetails.vue     |  96 ++++++++
 .../History/Graph/HistoryGraphMinimap.vue     | 233 ++++++++++++++++++
 .../History/Graph/HistoryGraphView.vue        | 144 +++++++++++
 .../History/Graph/historyGraphMapper.ts       | 208 ++++++++++++++++
 .../History/Graph/useHistoryGraphData.ts      |  55 +++++
 .../History/Graph/useHistoryGraphLayout.ts    | 158 ++++++++++++
 7 files changed, 895 insertions(+), 1 deletion(-)
 create mode 100644 client/src/components/History/Graph/HistoryGraphDetails.vue
 create mode 100644 client/src/components/History/Graph/HistoryGraphMinimap.vue
 create mode 100644 client/src/components/History/Graph/HistoryGraphView.vue
 create mode 100644 client/src/components/History/Graph/historyGraphMapper.ts
 create mode 100644 client/src/components/History/Graph/useHistoryGraphData.ts
 create mode 100644 client/src/components/History/Graph/useHistoryGraphLayout.ts

diff --git a/client/src/components/History/Content/model/states.ts b/client/src/components/History/Content/model/states.ts
index 39d1750a619..0dfaf272f39 100644
--- a/client/src/components/History/Content/model/states.ts
+++ b/client/src/components/History/Content/model/states.ts
@@ -40,7 +40,7 @@ export type State =
     | "new_populated_state"
     | "inaccessible";
 
-interface StateRepresentation {
+export interface StateRepresentation {
     status: "success" | "warning" | "info" | "danger" | "secondary";
     text?: string;
     displayName?: string;
diff --git a/client/src/components/History/Graph/HistoryGraphDetails.vue b/client/src/components/History/Graph/HistoryGraphDetails.vue
new file mode 100644
index 00000000000..381bac02a7c
--- /dev/null
+++ b/client/src/components/History/Graph/HistoryGraphDetails.vue
@@ -0,0 +1,96 @@
+<script setup lang="ts">
+import { BAlert } from "bootstrap-vue";
+import { computed, ref, watch } from "vue";
+
+import { GalaxyApi } from "@/api";
+import type { GraphNode } from "@/components/Graph/types";
+
+import Heading from "@/components/Common/Heading.vue";
+import GenericHistoryItem from "@/components/History/Content/GenericItem.vue";
+import JobInformation from "@/components/JobInformation/JobInformation.vue";
+import LoadingSpan from "@/components/LoadingSpan.vue";
+
+interface Props {
+    node: GraphNode;
+}
+
+const props = defineProps<Props>();
+
+const nodeType = computed(() => (props.node?.data?.type as string) ?? null);
+const encodedId = computed(() => (props.node?.data?.encodedId as string) ?? null);
+
+/** Map graph node type to the item source GenericHistoryItem expects */
+const itemSrc = computed(() => {
+    if (nodeType.value === "dataset") {
+        return "hda";
+    }
+    if (nodeType.value === "collection") {
+        return "hdca";
+    }
+    return null;
+});
+
+// Tool request -> job ID resolution
+const jobId = ref<string | null>(null);
+const jobLoading = ref(false);
+const jobError = ref<string | null>(null);
+
+watch(
+    () => [nodeType.value, encodedId.value],
+    async ([type, id]) => {
+        jobId.value = null;
+        jobError.value = null;
+        if (type !== "tool_request" || !id) {
+            return;
+        }
+        jobLoading.value = true;
+        try {
+            const { data, error } = await GalaxyApi().GET("/api/tool_requests/{id}", {
+                params: { path: { id: id as string } },
+            });
+            if (error) {
+                jobError.value = "Failed to load tool request details.";
+            } else if (data.jobs && data.jobs.length > 0) {
+                jobId.value = data.jobs[0]!.id;
+            } else {
+                jobError.value = "No job associated with this tool execution.";
+            }
+        } catch (e) {
+            jobError.value = "Failed to load tool request details.";
+        } finally {
+            jobLoading.value = false;
+        }
+    },
+    { immediate: true },
+);
+</script>
+
+<template>
+    <div class="history-graph-details border-left bg-white">
+        <div class="details-body">
+            <!-- Dataset or Collection -->
+            <div v-if="itemSrc && encodedId" :key="encodedId" class="p-2">
+                <Heading h1 separator inline size="md">
+                    {{ nodeType === "dataset" ? "Dataset Information" : "Collection Information" }}
+                </Heading>
+                <GenericHistoryItem :item-id="encodedId" :item-src="itemSrc" />
+            </div>
+
+            <!-- Tool request / Job details -->
+            <div v-else-if="nodeType === 'tool_request'" class="p-2">
+                <LoadingSpan v-if="jobLoading" message="Loading job details" />
+                <BAlert v-else-if="jobError" variant="info" show class="mb-0">{{ jobError }}</BAlert>
+                <JobInformation v-else-if="jobId" :job-id="jobId" :include-times="true" />
+            </div>
+        </div>
+    </div>
+</template>
+
+<style lang="scss" scoped>
+.history-graph-details {
+    flex-shrink: 0;
+    width: 320px;
+    height: 100%;
+    overflow-y: auto;
+}
+</style>
diff --git a/client/src/components/History/Graph/HistoryGraphMinimap.vue b/client/src/components/History/Graph/HistoryGraphMinimap.vue
new file mode 100644
index 00000000000..38a487f9a3c
--- /dev/null
+++ b/client/src/components/History/Graph/HistoryGraphMinimap.vue
@@ -0,0 +1,233 @@
+<script setup lang="ts">
+import type { Ref } from "vue";
+import { computed, onMounted, ref, toRef, watch } from "vue";
+
+import type { GraphLayout } from "@/components/Graph/types";
+import { useAnimationFrame } from "@/composables/sensors/animationFrame";
+import { useMinimapInteraction } from "@/composables/useMinimapInteraction";
+import { AxisAlignedBoundingBox } from "@/utils/geometry";
+
+// Colors resolved once at mount from CSS custom properties on the canvas element.
+// Uses brand-primary for nodes (set via SCSS in the scoped style block).
+let nodeColor = "#000";
+let viewColor = "rgba(0, 0, 0, 0.2)";
+let viewOutlineColor = "#000";
+
+const props = withDefaults(
+    defineProps<{
+        layout: GraphLayout | null;
+        viewportBoundingBox: AxisAlignedBoundingBox;
+        selectedNodeId?: string | null;
+        parentRight: number;
+        parentBottom: number;
+    }>(),
+    {
+        selectedNodeId: null,
+    },
+);
+
+const emit = defineEmits<{
+    (e: "panBy", offset: { x: number; y: number }): void;
+    (e: "moveTo", position: { x: number; y: number }): void;
+}>();
+
+const canvas: Ref<HTMLCanvasElement | null> = ref(null);
+const minimap: Ref<HTMLElement | null> = ref(null);
+let redraw = false;
+
+const MINIMAP_SIZE = 150;
+const MINIMAP_MIN = 50;
+const MINIMAP_MAX = 300;
+const MINIMAP_PADDING = 7;
+const MINIMAP_BORDER = 1;
+
+// ── Content bounds from layout ──
+
+const contentBounds = computed(() => {
+    const aabb = new AxisAlignedBoundingBox();
+    if (props.layout) {
+        for (const node of props.layout.nodes) {
+            aabb.fitRectangle({ x: node.x, y: node.y, width: node.width, height: node.height });
+        }
+        aabb.squareCenter();
+        aabb.expand(60);
+    }
+    return aabb;
+});
+
+const viewportBoundsRef = toRef(props, "viewportBoundingBox");
+const parentRightRef = toRef(props, "parentRight");
+const parentBottomRef = toRef(props, "parentBottom");
+
+// ── Shared interaction ──
+
+const { getCanvasTransform, recomputeTransform, minimapSize } = useMinimapInteraction({
+    canvasRef: canvas,
+    containerRef: minimap,
+    parentRight: parentRightRef,
+    parentBottom: parentBottomRef,
+    contentBounds,
+    viewportBounds: viewportBoundsRef,
+    panBy: (delta) => {
+        if (props.layout && props.layout.nodes.length > 0) {
+            emit("panBy", delta);
+        }
+    },
+    moveTo: (pos) => {
+        if (props.layout && props.layout.nodes.length > 0) {
+            emit("moveTo", pos);
+        }
+    },
+    storageKey: "graph-overview-size",
+    minSize: MINIMAP_MIN,
+    maxSize: MINIMAP_MAX,
+    defaultSize: MINIMAP_SIZE,
+});
+
+onMounted(() => {
+    if (canvas.value) {
+        const style = getComputedStyle(canvas.value);
+        nodeColor = style.getPropertyValue("--node-color").trim() || nodeColor;
+        viewColor = style.getPropertyValue("--view-color").trim() || viewColor;
+        viewOutlineColor = style.getPropertyValue("--view-outline-color").trim() || viewOutlineColor;
+    }
+    recomputeTransform();
+    redraw = true;
+});
+
+// ── Redraw triggers ──
+
+watch(
+    () => props.layout,
+    () => {
+        redraw = true;
+    },
+    { deep: true },
+);
+watch(
+    () => props.viewportBoundingBox,
+    () => {
+        redraw = true;
+    },
+    { deep: true },
+);
+watch(
+    () => props.selectedNodeId,
+    () => {
+        redraw = true;
+    },
+);
+watch(minimapSize, () => {
+    redraw = true;
+});
+watch(contentBounds, () => {
+    recomputeTransform();
+    redraw = true;
+});
+
+useAnimationFrame(() => {
+    if (redraw && canvas.value) {
+        renderMinimap();
+        redraw = false;
+    }
+});
+
+// ── Rendering ──
+
+function renderMinimap() {
+    const canvasTransform = getCanvasTransform();
+    const ctx = canvas.value!.getContext("2d") as CanvasRenderingContext2D;
+    ctx.resetTransform();
+    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+
+    if (!props.layout) {
+        return;
+    }
+
+    canvasTransform.applyToContext(ctx);
+
+    // Draw nodes
+    ctx.fillStyle = nodeColor;
+    ctx.beginPath();
+    for (const node of props.layout.nodes) {
+        ctx.rect(node.x, node.y, node.width, node.height);
+    }
+    ctx.fill();
+
+    // Draw selected node outline
+    if (props.selectedNodeId) {
+        const selected = props.layout.nodes.find((n) => n.id === props.selectedNodeId);
+        if (selected) {
+            const edge = 2 / canvasTransform.scaleX;
+            ctx.beginPath();
+            ctx.strokeStyle = nodeColor;
+            ctx.lineWidth = edge;
+            ctx.rect(selected.x - edge, selected.y - edge, selected.width + edge * 2, selected.height + edge * 2);
+            ctx.stroke();
+        }
+    }
+
+    // Draw viewport overlay
+    ctx.beginPath();
+    ctx.strokeStyle = viewOutlineColor;
+    ctx.fillStyle = viewColor;
+    ctx.lineWidth = 1 / canvasTransform.scaleX;
+    ctx.rect(
+        props.viewportBoundingBox.x,
+        props.viewportBoundingBox.y,
+        props.viewportBoundingBox.width,
+        props.viewportBoundingBox.height,
+    );
+    ctx.fill();
+    ctx.stroke();
+}
+</script>
+
+<template>
+    <div
+        ref="minimap"
+        class="graph-overview"
+        :style="{ '--graph-overview-size': `${minimapSize + MINIMAP_PADDING + MINIMAP_BORDER}px` }">
+        <canvas ref="canvas" class="graph-overview-body" :width="MINIMAP_MAX" :height="MINIMAP_MAX" />
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "bootstrap/scss/_functions.scss";
+@import "@/style/scss/theme/blue.scss";
+
+.graph-overview {
+    --graph-overview-size: 150px;
+
+    border-top-left-radius: 0.3rem;
+    cursor: nwse-resize;
+    position: absolute;
+    width: var(--graph-overview-size);
+    height: var(--graph-overview-size);
+    right: 0px;
+    bottom: 0px;
+    border-top: solid $border-color 1px;
+    border-left: solid $border-color 1px;
+    background: $white no-repeat url("@/assets/images/resizable.png");
+    z-index: 2000;
+    overflow: hidden;
+    padding: 7px 0 0 7px;
+
+    max-width: calc(300px + 7px + 1px);
+    max-height: calc(300px + 7px + 1px);
+    min-width: calc(50px + 7px + 1px);
+    min-height: calc(50px + 7px + 1px);
+
+    .graph-overview-body {
+        cursor: pointer;
+        position: relative;
+        overflow: hidden;
+        width: 100%;
+        height: 100%;
+
+        --node-color: #{$brand-primary};
+        --view-color: #{fade-out($brand-dark, 0.8)};
+        --view-outline-color: #{$brand-info};
+    }
+}
+</style>
diff --git a/client/src/components/History/Graph/HistoryGraphView.vue b/client/src/components/History/Graph/HistoryGraphView.vue
new file mode 100644
index 00000000000..362d964ba8f
--- /dev/null
+++ b/client/src/components/History/Graph/HistoryGraphView.vue
@@ -0,0 +1,144 @@
+<script setup lang="ts">
+import { faBezierCurve, faProjectDiagram } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BAlert } from "bootstrap-vue";
+import { computed, ref, toRef } from "vue";
+
+import type { EdgeStyle, GraphNode } from "@/components/Graph/types";
+import { useHistoryStore } from "@/stores/historyStore";
+
+import { useHistoryGraphData } from "./useHistoryGraphData";
+import { useHistoryGraphLayout } from "./useHistoryGraphLayout";
+
+import HistoryGraphDetails from "./HistoryGraphDetails.vue";
+import HistoryGraphMinimap from "./HistoryGraphMinimap.vue";
+import GButton from "@/components/BaseComponents/GButton.vue";
+import GButtonGroup from "@/components/BaseComponents/GButtonGroup.vue";
+import Heading from "@/components/Common/Heading.vue";
+import GraphView from "@/components/Graph/GraphView.vue";
+import LoadingSpan from "@/components/LoadingSpan.vue";
+
+interface Props {
+    historyId: string;
+    seedNodeId?: string;
+}
+
+const props = defineProps<Props>();
+
+// History name
+const historyStore = useHistoryStore();
+const historyName = computed(() => historyStore.getHistoryNameById(props.historyId));
+
+// Fetch params — product decisions owned here
+const limit = ref(500);
+
+const { graphData, loading, error } = useHistoryGraphData(toRef(props, "historyId"), limit, toRef(props, "seedNodeId"));
+
+// Layout
+const edgeStyle = ref<EdgeStyle>("orthogonal");
+const { layout, layoutLoading } = useHistoryGraphLayout(graphData, edgeStyle);
+
+// Selection
+const selectedNode = ref<GraphNode | null>(null);
+
+function onNodeSelected(node: GraphNode | null) {
+    selectedNode.value = node;
+}
+
+const isLoading = computed(() => loading.value || layoutLoading.value);
+const isTruncated = computed(() => {
+    const t = graphData.value?.truncated;
+    return t?.item_count_capped || t?.tool_request_count_capped || (t?.tool_requests_omitted ?? 0) > 0;
+});
+</script>
+
+<template>
+    <div class="history-graph-view">
+        <BAlert v-if="error" variant="danger" show>{{ error }}</BAlert>
+        <LoadingSpan v-else-if="isLoading" message="Loading history graph" />
+        <template v-else>
+            <div class="ui-form-header-underlay sticky-top" />
+            <div class="tool-header sticky-top bg-secondary px-2 py-1 mb-2 rounded">
+                <div class="d-flex justify-content-between align-items-center">
+                    <div class="py-1 d-flex flex-gapx-1 align-items-center">
+                        <FontAwesomeIcon :icon="faBezierCurve" class="fa-fw" />
+                        <Heading h1 inline bold size="text">{{ historyName }}</Heading>
+                    </div>
+                    <GButtonGroup>
+                        <GButton
+                            tooltip
+                            :title="'Orthogonal edges'"
+                            size="small"
+                            color="blue"
+                            :outline="edgeStyle !== 'orthogonal'"
+                            :pressed="edgeStyle === 'orthogonal'"
+                            @click="edgeStyle = 'orthogonal'">
+                            <FontAwesomeIcon :icon="faProjectDiagram" fixed-width />
+                        </GButton>
+                        <GButton
+                            tooltip
+                            :title="'Curved edges'"
+                            size="small"
+                            color="blue"
+                            :outline="edgeStyle !== 'curved'"
+                            :pressed="edgeStyle === 'curved'"
+                            @click="edgeStyle = 'curved'">
+                            <FontAwesomeIcon :icon="faBezierCurve" fixed-width />
+                        </GButton>
+                    </GButtonGroup>
+                </div>
+            </div>
+            <div class="history-graph-content">
+                <GraphView
+                    :layout="layout"
+                    :focus-node-id="seedNodeId ?? null"
+                    :edge-style="edgeStyle"
+                    :minimap-component="HistoryGraphMinimap"
+                    @nodeSelected="onNodeSelected" />
+                <HistoryGraphDetails v-if="selectedNode" :node="selectedNode" />
+            </div>
+            <div v-if="isTruncated" class="history-graph-truncation">
+                Showing a partial graph. Not all connections are visible.
+            </div>
+        </template>
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "@/style/scss/theme/blue.scss";
+
+.history-graph-view {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    min-height: 400px;
+}
+
+.history-graph-content {
+    display: flex;
+    flex-direction: row;
+    flex: 1;
+    min-height: 0;
+}
+
+.history-graph-truncation {
+    padding: 0.375rem 1rem;
+    background: $state-warning-bg;
+    color: $state-warning-text;
+    font-size: $h6-font-size;
+    text-align: center;
+    border-top: 1px solid $state-warning-border;
+}
+
+/* Tool request nodes use primary header (no dataset state) */
+:deep(.node-tool-request) .graph-node-header {
+    background: $brand-primary;
+    color: $white;
+}
+
+/* Dataset/collection nodes use state-driven coloring via data-state attribute */
+:deep(.node-dataset) .graph-node-header,
+:deep(.node-collection) .graph-node-header {
+    color: $text-color;
+}
+</style>
diff --git a/client/src/components/History/Graph/historyGraphMapper.ts b/client/src/components/History/Graph/historyGraphMapper.ts
new file mode 100644
index 00000000000..e830da59e29
--- /dev/null
+++ b/client/src/components/History/Graph/historyGraphMapper.ts
@@ -0,0 +1,208 @@
+import { faFile, faLayerGroup, faWrench } from "@fortawesome/free-solid-svg-icons";
+
+import type { components } from "@/api/schema";
+import type { GraphEdge, GraphNode, GraphNodePort } from "@/components/Graph/types";
+import { type StateRepresentation, STATES } from "@/components/History/Content/model/states";
+
+type ApiGraphNode = components["schemas"]["GraphNode"];
+type ApiGraphEdge = components["schemas"]["GraphEdge"];
+export type HistoryGraphResponse = components["schemas"]["HistoryGraphResponse"];
+
+/** Node width — uniform across all types */
+const NODE_WIDTH = 200;
+
+/** Compute node height based on content: header + ports + padding */
+const HEADER_LINE_HEIGHT = 20;
+const HEADER_PADDING = 10;
+const HEADER_ICON_CHARS = 3;
+const CHARS_PER_LINE = 22;
+const PORT_ROW_HEIGHT = 18;
+const RULE_HEIGHT = 5;
+const BODY_PADDING = 8;
+const MIN_NODE_HEIGHT = 32;
+
+function estimateHeaderLines(label: string): number {
+    const effectiveLength = label.length + HEADER_ICON_CHARS;
+    return Math.max(1, Math.ceil(effectiveLength / CHARS_PER_LINE));
+}
+
+function computeNodeHeight(
+    label: string,
+    inputCount: number,
+    outputCount: number,
+    hasBadgeBody: boolean = false,
+): number {
+    const headerLines = estimateHeaderLines(label);
+    const headerHeight = headerLines * HEADER_LINE_HEIGHT + HEADER_PADDING;
+    if (inputCount === 0 && outputCount === 0 && !hasBadgeBody) {
+        return Math.max(MIN_NODE_HEIGHT, headerHeight);
+    }
+    const portRows = inputCount + outputCount;
+    const rule = inputCount > 0 && outputCount > 0 ? RULE_HEIGHT : 0;
+    const badgeRow = hasBadgeBody ? PORT_ROW_HEIGHT + BODY_PADDING : 0;
+    return headerHeight + portRows * PORT_ROW_HEIGHT + rule + BODY_PADDING + badgeRow;
+}
+
+/** User-facing type labels */
+export const NODE_TYPE_LABELS: Record<string, string> = {
+    dataset: "Dataset",
+    collection: "Collection",
+    tool_request: "Tool Execution",
+};
+
+const NODE_ICONS: Record<string, typeof faFile> = {
+    dataset: faFile,
+    collection: faLayerGroup,
+    tool_request: faWrench,
+};
+
+const NODE_CSS_CLASS: Record<string, string> = {
+    dataset: "node-dataset",
+    collection: "node-collection",
+    tool_request: "node-tool-request",
+};
+
+// ── Label resolution ──
+
+function resolveNodeLabel(node: ApiGraphNode): string {
+    const hid = node.hid ? `${node.hid}: ` : "";
+    switch (node.type) {
+        case "dataset":
+            return `${hid}${node.name ?? node.extension ?? "Dataset"}`;
+        case "collection":
+            return `${hid}${node.name ?? node.collection_type ?? "Collection"}`;
+        case "tool_request":
+            return node.tool_name ?? shortenToolId(node.tool_id);
+    }
+}
+
+function resolveNodeBadge(node: ApiGraphNode): string | null {
+    switch (node.type) {
+        case "dataset":
+            return node.extension ?? null;
+        case "collection":
+            return node.collection_type ?? null;
+        case "tool_request":
+            return null;
+    }
+}
+
+function shortenToolId(toolId: string | null | undefined): string {
+    if (!toolId) {
+        return "Tool";
+    }
+    // Strip toolshed prefix:
+    // "toolshed.g2.bx.psu.edu/repos/iuc/bwa_mem/bwa_mem/1.0" → "bwa_mem"
+    const parts = toolId.split("/");
+    if (parts.length >= 2) {
+        return parts[parts.length - 2] ?? toolId;
+    }
+    return toolId;
+}
+
+function isCollectionEdge(edge: ApiGraphEdge): boolean {
+    return edge.type === "collection_input" || edge.type === "collection_output";
+}
+
+// ── Public API ──
+
+/**
+ * Map API graph nodes to generic GraphNode[] for the renderer.
+ * Returns nodes with dimensions, labels, icons, badges, and domain data.
+ */
+export function mapNodes(apiNodes: ApiGraphNode[], apiEdges: ApiGraphEdge[]): GraphNode[] {
+    // Build a lookup for node labels by ID
+    const nodeLabels = new Map<string, string>();
+    for (const node of apiNodes) {
+        nodeLabels.set(node.id, resolveNodeLabel(node));
+    }
+
+    // Build input/output port lists per node from edges
+    const inputPorts = new Map<string, GraphNodePort[]>();
+    const outputPorts = new Map<string, GraphNodePort[]>();
+    for (const edge of apiEdges) {
+        const sourceLabel = nodeLabels.get(edge.source) ?? edge.source;
+        const targetLabel = nodeLabels.get(edge.target) ?? edge.target;
+
+        // Target node gets an input port labeled by the source
+        if (!inputPorts.has(edge.target)) {
+            inputPorts.set(edge.target, []);
+        }
+        inputPorts.get(edge.target)!.push({ name: edge.source, label: sourceLabel });
+
+        // Source node gets an output port labeled by the target
+        if (!outputPorts.has(edge.source)) {
+            outputPorts.set(edge.source, []);
+        }
+        outputPorts.get(edge.source)!.push({ name: edge.target, label: targetLabel });
+    }
+
+    return apiNodes.map((node) => {
+        // Only tool_request nodes show input/output port lists.
+        // Dataset and collection nodes show state + badge in the body.
+        const isToolRequest = node.type === "tool_request";
+        const inputs = isToolRequest ? (inputPorts.get(node.id) ?? []) : [];
+        const outputs = isToolRequest ? (outputPorts.get(node.id) ?? []) : [];
+        const inputCount = inputPorts.get(node.id)?.length ?? 0;
+        const outputCount = outputPorts.get(node.id)?.length ?? 0;
+        const badge = resolveNodeBadge(node);
+
+        // For datasets/collections, use state to determine icon.
+        // State-based coloring is handled by data-state attribute on the node element,
+        // which triggers the global $galaxy-state-bg / $galaxy-state-border rules from base.scss.
+        // Collections return populated_state ("ok"/"new"/"failed") — map "failed" → "error"
+        // to align with the dataset state vocabulary used by the STATES map and CSS rules.
+        const rawState = node.state;
+        const displayState = rawState === "failed" ? "error" : rawState;
+        const stateKey = displayState as keyof typeof STATES | undefined;
+        const stateRep: StateRepresentation | null =
+            !isToolRequest && stateKey && stateKey in STATES ? STATES[stateKey] : null;
+        const icon = stateRep?.icon ?? NODE_ICONS[node.type] ?? faFile;
+        const cssClass = NODE_CSS_CLASS[node.type];
+
+        // Data nodes always have a body (badge + state text)
+        const hasBody = !isToolRequest;
+        const label = nodeLabels.get(node.id)!;
+        return {
+            id: node.id,
+            x: 0,
+            y: 0,
+            width: NODE_WIDTH,
+            height: computeNodeHeight(label, inputs.length, outputs.length, hasBody),
+            label,
+            icon,
+            badge,
+            cssClass,
+            inputs,
+            outputs,
+            data: {
+                type: node.type,
+                typeLabel: NODE_TYPE_LABELS[node.type] ?? node.type,
+                /** Encoded ID without the type prefix (d/c/r) */
+                encodedId: node.id.slice(1),
+                toolId: isToolRequest ? node.tool_id : null,
+                inputCount,
+                outputCount,
+                state: displayState,
+                stateText: stateRep?.text ?? null,
+                stateDisplayName: stateRep?.displayName ?? null,
+                stateSpin: stateRep?.spin ?? false,
+            },
+        };
+    });
+}
+
+/**
+ * Map API graph edges to generic GraphEdge[] for the renderer.
+ * Points are set to empty — the layout composable fills them in.
+ */
+export function mapEdges(apiEdges: ApiGraphEdge[]): GraphEdge[] {
+    return apiEdges.map((edge, idx) => ({
+        id: `e${idx}`,
+        source: edge.source,
+        target: edge.target,
+        cssClass: isCollectionEdge(edge) ? "edge-collection" : "edge-dataset",
+        isCollection: isCollectionEdge(edge),
+        points: [],
+    }));
+}
diff --git a/client/src/components/History/Graph/useHistoryGraphData.ts b/client/src/components/History/Graph/useHistoryGraphData.ts
new file mode 100644
index 00000000000..b787a4b4803
--- /dev/null
+++ b/client/src/components/History/Graph/useHistoryGraphData.ts
@@ -0,0 +1,55 @@
+import { type Ref, ref, watch } from "vue";
+
+import { GalaxyApi } from "@/api";
+
+import type { HistoryGraphResponse } from "./historyGraphMapper";
+
+/**
+ * Fetch the history-scoped graph from the API.
+ *
+ * The default call returns the full history graph (within bounds).
+ * An optional seed parameter requests a focused subgraph.
+ */
+export function useHistoryGraphData(historyId: Ref<string>, limit: Ref<number>, seed?: Ref<string | undefined>) {
+    const graphData = ref<HistoryGraphResponse | null>(null);
+    const loading = ref(false);
+    const error = ref<string | null>(null);
+
+    async function fetchGraph() {
+        loading.value = true;
+        error.value = null;
+
+        try {
+            const query: Record<string, unknown> = {
+                limit: limit.value,
+            };
+            if (seed?.value) {
+                query.seed = seed.value;
+            }
+
+            const { data, error: apiError } = await GalaxyApi().GET("/api/histories/{history_id}/graph", {
+                params: {
+                    path: { history_id: historyId.value },
+                    query: query as any,
+                },
+            });
+
+            if (apiError) {
+                error.value = apiError.err_msg || "Failed to load graph";
+                graphData.value = null;
+            } else {
+                graphData.value = data;
+            }
+        } catch (e) {
+            error.value = e instanceof Error ? e.message : "Failed to load graph";
+            graphData.value = null;
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    const watchSources = seed ? [historyId, limit, seed] : [historyId, limit];
+    watch(watchSources, () => fetchGraph(), { immediate: true });
+
+    return { graphData, loading, error };
+}
diff --git a/client/src/components/History/Graph/useHistoryGraphLayout.ts b/client/src/components/History/Graph/useHistoryGraphLayout.ts
new file mode 100644
index 00000000000..12ead29cdff
--- /dev/null
+++ b/client/src/components/History/Graph/useHistoryGraphLayout.ts
@@ -0,0 +1,158 @@
+import ELK, { type ElkExtendedEdge, type ElkNode } from "elkjs/lib/elk.bundled";
+import { type Ref, ref, watch } from "vue";
+
+import type { EdgeStyle, GraphEdge, GraphLayout, GraphNode } from "@/components/Graph/types";
+import { computeControlPoints } from "@/utils/connectionPath";
+
+import { type HistoryGraphResponse, mapEdges, mapNodes } from "./historyGraphMapper";
+
+const elk = new ELK();
+
+/**
+ * Composable that takes API graph data and produces a positioned layout using ELK.js.
+ *
+ * Uses the history graph mapper to convert API types to generic graph types,
+ * then runs ELK layered layout and extracts positioned nodes and edge paths.
+ *
+ * edgeStyle controls how edge points are computed:
+ * - "orthogonal": uses ELK's routed sections (straight segments with bends)
+ * - "curved": computes bezier control points between node ports (workflow editor style)
+ */
+export function useHistoryGraphLayout(
+    graphData: Ref<HistoryGraphResponse | null>,
+    edgeStyle: Ref<EdgeStyle> = ref("orthogonal") as Ref<EdgeStyle>,
+) {
+    const layout = ref<GraphLayout | null>(null);
+    const layoutLoading = ref(false);
+
+    watch(
+        [graphData, edgeStyle],
+        async ([data, style]) => {
+            if (!data || data.nodes.length === 0) {
+                layout.value = null;
+                return;
+            }
+
+            layoutLoading.value = true;
+            try {
+                layout.value = await computeLayout(data, style);
+            } catch (e) {
+                console.error("History graph layout failed:", e);
+                layout.value = null;
+            } finally {
+                layoutLoading.value = false;
+            }
+        },
+        { immediate: true },
+    );
+
+    return { layout, layoutLoading };
+}
+
+async function computeLayout(data: HistoryGraphResponse, style: EdgeStyle): Promise<GraphLayout> {
+    // Map API types to generic graph types via the history mapper
+    const graphNodes = mapNodes(data.nodes, data.edges);
+    const graphEdges = mapEdges(data.edges);
+
+    // Build ELK graph
+    const elkChildren: ElkNode[] = graphNodes.map((node) => ({
+        id: node.id,
+        width: node.width,
+        height: node.height,
+    }));
+
+    const elkEdges: ElkExtendedEdge[] = graphEdges.map((edge) => ({
+        id: edge.id,
+        sources: [edge.source],
+        targets: [edge.target],
+    }));
+
+    const elkGraph: ElkNode = {
+        id: "root",
+        layoutOptions: {
+            "elk.algorithm": "layered",
+            "elk.direction": "RIGHT",
+            "elk.layered.nodePlacement.strategy": "NETWORK_SIMPLEX",
+            "elk.layered.spacing.baseValue": "80",
+            "elk.spacing.nodeNode": "40",
+            "elk.layered.spacing.nodeNodeBetweenLayers": "80",
+            "elk.edgeRouting": "ORTHOGONAL",
+        },
+        children: elkChildren,
+        edges: elkEdges,
+    };
+
+    const result = await elk.layout(elkGraph);
+
+    // Apply ELK positions to graph nodes
+    const nodeById = new Map(graphNodes.map((n) => [n.id, n]));
+    const layoutNodes: GraphNode[] = (result.children ?? []).map((elkNode) => {
+        const gn = nodeById.get(elkNode.id)!;
+        return {
+            ...gn,
+            x: elkNode.x ?? 0,
+            y: elkNode.y ?? 0,
+            width: elkNode.width ?? gn.width,
+            height: elkNode.height ?? gn.height,
+        };
+    });
+
+    // Build node position lookup for edge routing
+    const nodePositions = new Map<string, { x: number; y: number; w: number; h: number }>();
+    for (const n of layoutNodes) {
+        nodePositions.set(n.id, { x: n.x, y: n.y, w: n.width, h: n.height });
+    }
+
+    let layoutEdges: GraphEdge[];
+
+    if (style === "curved") {
+        // Compute bezier control points between node ports (workflow editor style)
+        layoutEdges = graphEdges.map((ge) => {
+            const src = nodePositions.get(ge.source);
+            const tgt = nodePositions.get(ge.target);
+            let points: { x: number; y: number }[] = [];
+            if (src && tgt) {
+                const controlPoints = computeControlPoints(src.x + src.w, src.y + src.h / 2, tgt.x, tgt.y + tgt.h / 2);
+                points = controlPoints.map(([x, y]) => ({ x, y }));
+            }
+            return { ...ge, points };
+        });
+    } else {
+        // Extract edge paths from ELK's orthogonal routing sections
+        const edgeById = new Map(graphEdges.map((e) => [e.id, e]));
+        layoutEdges = (result.edges ?? []).map((elkEdge) => {
+            const ge = edgeById.get(elkEdge.id)!;
+            const points: { x: number; y: number }[] = [];
+
+            const sections = (elkEdge as ElkExtendedEdge).sections ?? [];
+            for (const section of sections) {
+                points.push({ x: section.startPoint.x, y: section.startPoint.y });
+                if (section.bendPoints) {
+                    for (const bp of section.bendPoints) {
+                        points.push({ x: bp.x, y: bp.y });
+                    }
+                }
+                points.push({ x: section.endPoint.x, y: section.endPoint.y });
+            }
+
+            // Fallback: straight line between node edges
+            if (points.length === 0) {
+                const src = nodePositions.get(ge.source);
+                const tgt = nodePositions.get(ge.target);
+                if (src && tgt) {
+                    points.push({ x: src.x + src.w, y: src.y + src.h / 2 });
+                    points.push({ x: tgt.x, y: tgt.y + tgt.h / 2 });
+                }
+            }
+
+            return { ...ge, points };
+        });
+    }
+
+    return {
+        nodes: layoutNodes,
+        edges: layoutEdges,
+        width: result.width ?? 0,
+        height: result.height ?? 0,
+    };
+}

From 3edbebccada77209bc13394a3625149fed3acac9 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:31:31 +0300
Subject: [PATCH 07/28] Wire history graph route and menu entry.

---
 client/src/components/History/HistoryOptions.test.ts | 9 ++++++++-
 client/src/components/History/HistoryOptions.vue     | 6 ++++++
 client/src/entry/analysis/router.js                  | 9 +++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/client/src/components/History/HistoryOptions.test.ts b/client/src/components/History/HistoryOptions.test.ts
index a6a36a77782..aae57772d51 100644
--- a/client/src/components/History/HistoryOptions.test.ts
+++ b/client/src/components/History/HistoryOptions.test.ts
@@ -25,11 +25,18 @@ const expectedOptions = [
     "Archive History",
     "Extract Workflow",
     "Show Invocations",
+    "Show History Graph",
     "Share & Manage Access",
 ];
 
 // options enabled for logged-out users
-const anonymousOptions = ["Resume Paused Jobs", "Delete History", "Export Tool References", "Export History to File"];
+const anonymousOptions = [
+    "Resume Paused Jobs",
+    "Delete History",
+    "Export Tool References",
+    "Export History to File",
+    "Show History Graph",
+];
 
 // options disabled for logged-out users
 const anonymousDisabledOptions = expectedOptions.filter((option) => !anonymousOptions.includes(option));
diff --git a/client/src/components/History/HistoryOptions.vue b/client/src/components/History/HistoryOptions.vue
index bb02389d1bc..8a188ab830a 100644
--- a/client/src/components/History/HistoryOptions.vue
+++ b/client/src/components/History/HistoryOptions.vue
@@ -2,6 +2,7 @@
 import {
     faArchive,
     faBars,
+    faBezierCurve,
     faBurn,
     faClone,
     faColumns,
@@ -231,6 +232,11 @@ watch(
                 <span v-localize>Show Invocations</span>
             </BDropdownItem>
 
+            <BDropdownItem :title="localize('View History Graph')" :to="`/histories/${history.id}/graph`">
+                <FontAwesomeIcon fixed-width :icon="faBezierCurve" />
+                <span v-localize>Show History Graph</span>
+            </BDropdownItem>
+
             <BDropdownDivider />
 
             <BDropdownItem
diff --git a/client/src/entry/analysis/router.js b/client/src/entry/analysis/router.js
index d8961895b20..4ce9bcc7234 100644
--- a/client/src/entry/analysis/router.js
+++ b/client/src/entry/analysis/router.js
@@ -43,6 +43,7 @@ import GridVisualization from "@/components/Grid/GridVisualization.vue";
 import HelpTerm from "@/components/Help/HelpTerm.vue";
 import HistoryArchiveWizard from "@/components/History/Archiving/HistoryArchiveWizard.vue";
 import HistoryExportTasks from "@/components/History/Export/HistoryExport.vue";
+import HistoryGraphView from "@/components/History/Graph/HistoryGraphView.vue";
 import HistoryAccessibility from "@/components/History/HistoryAccessibility.vue";
 import HistoryDatasetPermissions from "@/components/History/HistoryDatasetPermissions.vue";
 import HistoryList from "@/components/History/HistoryList.vue";
@@ -426,6 +427,14 @@ export function getRouter(Galaxy) {
                         component: WorkflowExtractionForm,
                         props: true,
                     },
+                    {
+                        path: "histories/:historyId/graph",
+                        component: HistoryGraphView,
+                        props: (route) => ({
+                            historyId: route.params.historyId,
+                            seedNodeId: route.query.seed || undefined,
+                        }),
+                    },
                     {
                         path: "interactivetool_entry_points/list",
                         component: InteractiveTools,

From 91a5978e777207e3b280ef67111f269cea674b63 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Mon, 13 Apr 2026 11:34:11 +0300
Subject: [PATCH 08/28] Update tests, apply lint

---
 client/src/api/schema/schema.ts               |  25 --
 .../History/Graph/HistoryGraphView.vue        |   5 +-
 lib/galaxy/managers/history_graph.py          |  79 ++--
 .../app/managers/test_HistoryGraphBuilder.py  | 393 +++---------------
 4 files changed, 101 insertions(+), 401 deletions(-)

diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index e03dcf387fc..8a66eab194f 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -13149,11 +13149,6 @@ export interface components {
             id: string;
             /** Name */
             name?: string | null;
-            /**
-             * Partial
-             * @description True if this tool_request has edges on only one side (input or output) within the current graph scope. This can mean the other side is outside the scope window, was suppressed during collapsing, or the tool genuinely has no inputs. None for fully connected tool_requests and non-tool_request nodes.
-             */
-            partial?: boolean | null;
             /** State */
             state?: string | null;
             /** Tool Id */
@@ -23819,26 +23814,6 @@ export interface components {
             scope_type: "recent" | "window" | "seed_centered";
             /** Seed In Scope */
             seed_in_scope?: boolean | null;
-            /**
-             * Tool Request Count Capped
-             * @default false
-             */
-            tool_request_count_capped: boolean;
-            /**
-             * Tool Requests Omitted
-             * @default 0
-             */
-            tool_requests_omitted: number;
-            /**
-             * Tool Requests Partial
-             * @default 0
-             */
-            tool_requests_partial: number;
-            /**
-             * Total History Items
-             * @default 0
-             */
-            total_history_items: number;
         };
         /** UndeleteHistoriesPayload */
         UndeleteHistoriesPayload: {
diff --git a/client/src/components/History/Graph/HistoryGraphView.vue b/client/src/components/History/Graph/HistoryGraphView.vue
index 362d964ba8f..27bc0e58e80 100644
--- a/client/src/components/History/Graph/HistoryGraphView.vue
+++ b/client/src/components/History/Graph/HistoryGraphView.vue
@@ -46,10 +46,7 @@ function onNodeSelected(node: GraphNode | null) {
 }
 
 const isLoading = computed(() => loading.value || layoutLoading.value);
-const isTruncated = computed(() => {
-    const t = graphData.value?.truncated;
-    return t?.item_count_capped || t?.tool_request_count_capped || (t?.tool_requests_omitted ?? 0) > 0;
-});
+const isTruncated = computed(() => graphData.value?.truncated?.item_count_capped ?? false);
 </script>
 
 <template>
diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 45f3c12c709..64e9f2e742b 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -5,7 +5,6 @@ tool_request and that tool_request's declared inputs from the
 submission payload.  One hop only.  No consumers.  No transitive
 traversal.
 
-See ``~/claude/history_graph/reduced_provenance_model.md``.
 """
 
 import json
@@ -13,6 +12,7 @@ import logging
 from typing import Optional
 
 from sqlalchemy import (
+    Select,
     select,
     union_all,
 )
@@ -197,7 +197,7 @@ class HistoryGraphBuilder:
         self.newer_than_hid = row.hid - half - 1
 
     def _select_items(self) -> tuple[set[int], set[int], bool, Optional[int], Optional[int]]:
-        hda_q = select(
+        hda_q: Select = select(
             HistoryDatasetAssociation.id,
             HistoryDatasetAssociation.hid,
             literal_column("'dataset'").label("item_type"),
@@ -209,7 +209,7 @@ class HistoryGraphBuilder:
         if self.newer_than_hid is not None:
             hda_q = hda_q.where(HistoryDatasetAssociation.hid > self.newer_than_hid)
 
-        hdca_q = select(
+        hdca_q: Select = select(
             HistoryDatasetCollectionAssociation.id,
             HistoryDatasetCollectionAssociation.hid,
             literal_column("'collection'").label("item_type"),
@@ -222,7 +222,11 @@ class HistoryGraphBuilder:
             hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.hid > self.newer_than_hid)
 
         combined = union_all(hda_q, hdca_q).subquery()
-        stmt = select(combined.c.id, combined.c.hid, combined.c.item_type).order_by(combined.c.hid.desc()).limit(self.limit + 1)
+        stmt = (
+            select(combined.c.id, combined.c.hid, combined.c.item_type)
+            .order_by(combined.c.hid.desc())
+            .limit(self.limit + 1)
+        )
 
         dataset_ids: set[int] = set()
         collection_ids: set[int] = set()
@@ -253,7 +257,10 @@ class HistoryGraphBuilder:
             stmt = (
                 select(HistoryDatasetAssociation.id)
                 .join(DatasetCollectionElement, DatasetCollectionElement.hda_id == HistoryDatasetAssociation.id)
-                .where(HistoryDatasetAssociation.id.in_(chunk), HistoryDatasetAssociation.visible == False)  # noqa: E712
+                .where(
+                    HistoryDatasetAssociation.id.in_(chunk),
+                    HistoryDatasetAssociation.visible == False,  # noqa: E712
+                )
                 .distinct()
             )
             for row in self.sa_session.execute(stmt):
@@ -450,16 +457,18 @@ class HistoryGraphBuilder:
                 .where(HistoryDatasetAssociation.id.in_(chunk))
             )
             for row in self.sa_session.execute(stmt):
-                nodes.append(GraphNode(
-                    id=self._encode("dataset", row.id),
-                    type="dataset",
-                    name=row.name,
-                    hid=row.hid,
-                    state=row._state if row._state else row.dataset_state,
-                    extension=row.extension,
-                    deleted=row.deleted,
-                    visible=row.visible,
-                ))
+                nodes.append(
+                    GraphNode(
+                        id=self._encode("dataset", row.id),
+                        type="dataset",
+                        name=row.name,
+                        hid=row.hid,
+                        state=row._state if row._state else row.dataset_state,
+                        extension=row.extension,
+                        deleted=row.deleted,
+                        visible=row.visible,
+                    )
+                )
         return nodes
 
     def _collection_nodes(self, db_ids: set[int]) -> list[GraphNode]:
@@ -479,16 +488,18 @@ class HistoryGraphBuilder:
                 .where(HistoryDatasetCollectionAssociation.id.in_(chunk))
             )
             for row in self.sa_session.execute(stmt):
-                nodes.append(GraphNode(
-                    id=self._encode("collection", row.id),
-                    type="collection",
-                    name=row.name,
-                    hid=row.hid,
-                    state=row.populated_state,
-                    collection_type=row.collection_type,
-                    deleted=row.deleted,
-                    visible=row.visible,
-                ))
+                nodes.append(
+                    GraphNode(
+                        id=self._encode("collection", row.id),
+                        type="collection",
+                        name=row.name,
+                        hid=row.hid,
+                        state=row.populated_state,
+                        collection_type=row.collection_type,
+                        deleted=row.deleted,
+                        visible=row.visible,
+                    )
+                )
         return nodes
 
     def _tr_nodes(self, tr_map: dict[int, Optional[str]]) -> list[GraphNode]:
@@ -517,9 +528,7 @@ class HistoryGraphBuilder:
 
     # ── Seed subgraph filter (in-memory only) ──
 
-    def _seed_filter(
-        self, nodes: list[GraphNode], edges: list[GraphEdge]
-    ) -> tuple[list[GraphNode], list[GraphEdge]]:
+    def _seed_filter(self, nodes: list[GraphNode], edges: list[GraphEdge]) -> tuple[list[GraphNode], list[GraphEdge]]:
         from galaxy.exceptions import RequestParameterInvalidException
 
         if not self.seed or len(self.seed) < 2:
@@ -557,11 +566,13 @@ class HistoryGraphBuilder:
     def _sort(self, nodes: list[GraphNode], edges: list[GraphEdge]) -> tuple[list[GraphNode], list[GraphEdge]]:
         fallback = (99, 0)
         nodes.sort(key=lambda n: self._sort_keys.get(n.id, fallback))
-        edges.sort(key=lambda e: (
-            self._sort_keys.get(e.source, fallback),
-            self._sort_keys.get(e.target, fallback),
-            EDGE_TYPE_RANK.get(e.type, 99),
-        ))
+        edges.sort(
+            key=lambda e: (
+                self._sort_keys.get(e.source, fallback),
+                self._sort_keys.get(e.target, fallback),
+                EDGE_TYPE_RANK.get(e.type, 99),
+            )
+        )
         return nodes, edges
 
     # ── Utilities ──
@@ -573,4 +584,4 @@ class HistoryGraphBuilder:
 
     @staticmethod
     def _chunks(items: list) -> list[list]:
-        return [items[i:i + CHUNK] for i in range(0, len(items), CHUNK)] if items else []
+        return [items[i : i + CHUNK] for i in range(0, len(items), CHUNK)] if items else []
diff --git a/test/unit/app/managers/test_HistoryGraphBuilder.py b/test/unit/app/managers/test_HistoryGraphBuilder.py
index ecc1c9f7527..8642776b310 100644
--- a/test/unit/app/managers/test_HistoryGraphBuilder.py
+++ b/test/unit/app/managers/test_HistoryGraphBuilder.py
@@ -108,9 +108,22 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         session.flush()
         return job
 
+    def _append_payload_input(self, job, ref):
+        if job.tool_request_id is None:
+            return
+        tr = self.trans.sa_session.get(model.ToolRequest, job.tool_request_id)
+        if tr is None:
+            return
+        payload = dict(tr.request) if isinstance(tr.request, dict) else {}
+        inputs = list(payload.get("inputs", []))
+        inputs.append(ref)
+        payload["inputs"] = inputs
+        tr.request = payload
+
     def _link_job_input_hda(self, job, hda, name="input"):
         assoc = model.JobToInputDatasetAssociation(name=name, dataset=hda)
         assoc.job_id = job.id
+        self._append_payload_input(job, {"src": "hda", "id": hda.id})
         session = self.trans.sa_session
         session.add(assoc)
         session.flush()
@@ -119,11 +132,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
     def _link_job_output_hda(self, job, hda, name="output"):
         assoc = model.JobToOutputDatasetAssociation(name=name, dataset=hda)
         assoc.job_id = job.id
-        # Mirror production behavior (Job.add_output_dataset, model/__init__.py).
-        # The lean builder resolves HDA producers via Dataset.job_id (Rule N1,
-        # copy-safe), so the test fixture must also wire up that edge.
-        if hda.dataset.job_id is None:
-            hda.dataset.job_id = job.id
         session = self.trans.sa_session
         session.add(assoc)
         session.flush()
@@ -132,6 +140,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
     def _link_job_input_hdca(self, job, hdca, name="input"):
         assoc = model.JobToInputDatasetCollectionAssociation(name=name, dataset_collection=hdca)
         assoc.job_id = job.id
+        self._append_payload_input(job, {"src": "hdca", "id": hdca.id})
         session = self.trans.sa_session
         session.add(assoc)
         session.flush()
@@ -200,7 +209,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         assert graph.truncated.oldest_hid_included is not None
         assert graph.truncated.newest_hid_included is not None
         assert graph.truncated.newest_hid_included >= graph.truncated.oldest_hid_included
-        
+
     def test_full_history_graph(self):
         """Full history graph includes all items and edges."""
         history, _ = self._create_history()
@@ -512,11 +521,11 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         input_edges = [e for e in graph.edges if e.target == tr_enc]
         assert len(input_edges) == 1
 
-    def test_deleted_input_not_in_consumer_edges(self):
-        """A deleted input HDA is excluded from scope and produces no consumer edge.
+    def test_deleted_input_not_in_graph(self):
+        """A deleted input HDA is filtered from the graph (not a node).
 
-        The bounded model only creates consumer edges for selected items.
-        A deleted HDA is not selected (unless include_deleted=True).
+        The bounded model excludes deleted items from both the initial
+        scope and the closure set (unless include_deleted=True).
         """
         history, _ = self._create_history()
         dataset = self.dataset_manager.create()
@@ -534,10 +543,10 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
 
         graph = self._build_graph(history)
 
-        tr_enc = self._encode("r", tr.id)
-        # No consumer edge for deleted execution_hda (not in scope)
-        input_edges = [e for e in graph.edges if e.target == tr_enc and e.type == "dataset_input"]
-        assert len(input_edges) == 0
+        node_ids = {n.id for n in graph.nodes}
+        assert self._encode("d", execution_hda.id) not in node_ids
+        assert self._encode("d", visible_copy.id) in node_ids
+        assert self._encode("d", output_hda.id) in node_ids
 
     def test_hidden_non_element_hda_included(self):
         """Hidden HDAs that are NOT collection elements appear as graph nodes."""
@@ -584,8 +593,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         assert len(tr_nodes) == 1
         assert graph.truncated.item_count_capped is True
 
-        # Closure pulled in the boundary item.
-        assert graph.truncated.closure_items_added >= 1
         node_ids = {n.id for n in graph.nodes}
         assert self._encode("d", input_hda.id) in node_ids
         assert self._encode("d", output_hda.id) in node_ids
@@ -900,42 +907,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         assert self._encode("d", copy3.id) in node_ids
         assert len(graph.nodes) == 3
 
-    def test_n1_copied_hda_has_producer_edge(self):
-        """Rule N1: a copied HDA (no JobToOutputDatasetAssociation row of
-        its own) still gets a producer edge via ``Dataset.job_id``.
-
-        Mirrors the production invariant that ``Job.add_output_dataset``
-        sets ``Dataset.job_id`` on the underlying Dataset, which is then
-        shared between the original HDA and any copies.  A copy inherits
-        producer attribution through the shared Dataset.
-        """
-        history, _ = self._create_history()
-        # Original: create an HDA and link it as the named output of a job.
-        # The test helper mirrors production by also setting Dataset.job_id.
-        original = self._create_hda(history, name="original")
-        tr = self._create_tool_request(history)
-        job = self._create_job(tool_request=tr, tool_id="producer_tool")
-        self._link_job_output_hda(job, original)
-
-        # Copy: a second HDA on the *same* Dataset, with NO
-        # JobToOutputDatasetAssociation row.  In the old builder (which
-        # looked up via that table) this HDA would have no producer edge.
-        copy = self.hda_manager.create(name="copy", history=history, dataset=original.dataset)
-        self.trans.sa_session.flush()
-
-        graph = self._build_graph(history)
-
-        tr_enc = self._encode("r", tr.id)
-        original_enc = self._encode("d", original.id)
-        copy_enc = self._encode("d", copy.id)
-
-        # Both the original AND the copy have producer edges from tr.
-        producer_edges = {
-            (e.source, e.target) for e in graph.edges if e.type == "dataset_output"
-        }
-        assert (tr_enc, original_enc) in producer_edges, "Original should have producer edge"
-        assert (tr_enc, copy_enc) in producer_edges, "Copy should have producer edge via Dataset.job_id (N1)"
-
     def test_closure_resolves_hidden_element_input_to_parent_collection(self):
         """Real-data bug fix: a tool consumes a hidden element HDA
         directly via JobToInputDatasetAssociation (not via the
@@ -979,10 +950,9 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         # dataset_input edge to the hidden forward element (which N3
         # filters out as not-top-level).
         in_edges = [e for e in graph.edges if e.target == tr_enc]
-        assert len(in_edges) == 1, (
-            "Tool consuming hidden element HDA must have its parent collection "
-            "surfaced as a closure input"
-        )
+        assert (
+            len(in_edges) == 1
+        ), "Tool consuming hidden element HDA must have its parent collection surfaced as a closure input"
         edge = in_edges[0]
         assert edge.type == "collection_input"
         assert edge.source == self._encode("c", paired.id)
@@ -1063,63 +1033,12 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
 
         tr_enc = self._encode("r", tr.id)
         hdca_enc = self._encode("c", hdca.id)
-        producer_edges = {
-            (e.source, e.target) for e in graph.edges if e.type == "collection_output"
-        }
-        assert (tr_enc, hdca_enc) in producer_edges, (
-            "HDCA producer edge must come from JobToOutputDatasetCollectionAssociation "
-            "even when HDCA.job_id is None"
-        )
-
-    def test_n2_implicit_collection_has_producer_edge(self):
-        """Rule N2: an HDCA produced via an implicit collection (map-over
-        output, ``HDCA.implicit_collection_jobs_id`` set) gets a producer
-        edge via the ``ImplicitCollectionJobsJobAssociation`` UNION branch.
-
-        This case was silently broken in the old builder which only
-        looked at ``HDCA.job_id``.
-        """
-        history, _ = self._create_history()
-        # Build an implicit-collection map-over: input collection, element
-        # jobs, output collection with implicit_collection_jobs_id set.
-        in_el = self._create_hda(history, name="el_in")
-        out_el = self._create_hda(history, name="el_out")
-        element_identifiers_in = self.build_element_identifiers([in_el])
-        self.collection_manager.create(
-            self.trans, history, "input list", "list", element_identifiers=element_identifiers_in
-        )
-        element_identifiers_out = self.build_element_identifiers([out_el])
-        output_hdca = self.collection_manager.create(
-            self.trans, history, "output list", "list", element_identifiers=element_identifiers_out
-        )
-
-        # Wire the implicit-collection-jobs chain: ICJ + ICJJA + HDCA link.
-        tr = self._create_tool_request(history)
-        job = self._create_job(tool_request=tr, tool_id="map_tool")
-        self._link_job_input_hda(job, in_el)
-        self._link_job_output_hda(job, out_el)
-
-        icj = model.ImplicitCollectionJobs(populated_state="ok")
-        self.trans.sa_session.add(icj)
-        self.trans.sa_session.flush()
-        icja = model.ImplicitCollectionJobsJobAssociation()
-        icja.implicit_collection_jobs_id = icj.id
-        icja.job_id = job.id
-        icja.order_index = 0
-        self.trans.sa_session.add(icja)
-        output_hdca.implicit_collection_jobs_id = icj.id
-        self.trans.sa_session.flush()
-
-        graph = self._build_graph(history)
-
-        tr_enc = self._encode("r", tr.id)
-        hdca_enc = self._encode("c", output_hdca.id)
-
-        producer_edges = {
-            (e.source, e.target) for e in graph.edges if e.type == "collection_output"
-        }
-        assert (tr_enc, hdca_enc) in producer_edges, (
-            "Implicit output HDCA should have producer edge via ICJ path (N2)"
+        producer_edges = {(e.source, e.target) for e in graph.edges if e.type == "collection_output"}
+        assert (
+            tr_enc,
+            hdca_enc,
+        ) in producer_edges, (
+            "HDCA producer edge must come from JobToOutputDatasetCollectionAssociation even when HDCA.job_id is None"
         )
 
     def test_n2_ambiguous_hdca_producer_has_node_but_no_edge(self):
@@ -1165,8 +1084,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         hdca.implicit_collection_jobs_id = icj.id  # implicit branch
         self.trans.sa_session.flush()
 
-        # Build via a fresh builder instance so we can inspect the
-        # internal debug counter after build().
         builder = HistoryGraphBuilder(
             sa_session=self.trans.sa_session,
             security=self.app.security,
@@ -1180,17 +1097,8 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         assert hdca_enc in node_ids, "Ambiguous HDCA should still be a node"
 
         # No producer edge for this HDCA.
-        producer_targets = {
-            e.target for e in graph.edges if e.type == "collection_output"
-        }
-        assert hdca_enc not in producer_targets, (
-            "Ambiguous HDCA must NOT get a producer edge (N2 fallback)"
-        )
-
-        # Internal debug counter recorded the ambiguity.
-        assert builder._hdca_producer_ambiguity_count >= 1, (
-            "Ambiguity counter should have incremented"
-        )
+        producer_targets = {e.target for e in graph.edges if e.type == "collection_output"}
+        assert hdca_enc not in producer_targets, "Ambiguous HDCA must NOT get a producer edge (N2 fallback)"
 
     def test_seed_filter_issues_no_extra_queries(self):
         """Stage 9 lock: ``_extract_subgraph`` operates only on the
@@ -1247,9 +1155,9 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
             f"Seeded build issued {seeded_count} SQL statements, "
             f"unseeded issued {unseeded_count}. Stage 9 must not trigger extra DB access."
         )
-        assert seeded_ids.issubset(unseeded_ids), (
-            "Seeded result must be a subset of unseeded — seed is a pure post-filter"
-        )
+        assert seeded_ids.issubset(
+            unseeded_ids
+        ), "Seeded result must be a subset of unseeded — seed is a pure post-filter"
         assert seed_enc in seeded_ids, "Seed itself should be in the seeded result"
 
     def test_closure_invariant_no_partial_executions(self):
@@ -1277,9 +1185,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         # For each tool_request in the graph, all its incident edges
         # must reference items that are also nodes in the graph.
         for tr_node in tr_nodes:
-            connected_items = {
-                e.source for e in graph.edges if e.target == tr_node.id
-            } | {
+            connected_items = {e.source for e in graph.edges if e.target == tr_node.id} | {
                 e.target for e in graph.edges if e.source == tr_node.id
             }
             for item_id in connected_items:
@@ -1292,131 +1198,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
                 "expected at least one input and one output after closure"
             )
 
-    def test_closure_pulls_items_but_not_recursive_executions(self):
-        """Closure expands ITEMS only, never recursively pulls in new
-        execution nodes from those added items.
-
-        Build a longer chain so we can isolate a single seed item that
-        has its OWN producer + consumer in scope, and verify closure
-        does NOT bring in the producer/consumer of items further out.
-
-        chain: hda0 → tr0 → hda1 → tr1 → hda2 → tr2 → hda3 → tr3 → hda4
-        seed: only hda2 (via tight hid window)
-        Expected after closure:
-          - hda2 is in seed
-          - tr1 is producer of hda2 → in graph (sticky)
-          - tr2 is consumer of hda2 → in graph (non-sticky)
-          - closure pulls in hda1 (input to tr1) and hda3 (output of tr2)
-          - tr0 (producer of hda1) is NOT in graph — closure pulled in
-            hda1 as an item but did NOT recurse to its producer
-          - tr3 (consumer of hda3) is NOT in graph — same reason
-        """
-        history, _ = self._create_history()
-        chain = self._build_linear_chain(history, length=4)
-        # chain[i] = (input_hda_i, tr_i, output_hda_i)
-        # The output of step i is the input of step i+1
-        hda2 = chain[1][2]  # output of tr1, input of tr2
-        tr0 = chain[0][1]
-        tr1 = chain[1][1]
-        tr2 = chain[2][1]
-        tr3 = chain[3][1]
-
-        # Seed window holds hda2 only.  Use a generous limit so the
-        # closure cap (= limit) does not fire.
-        graph = self._build_graph(
-            history,
-            older_than_hid=hda2.hid + 1,
-            newer_than_hid=hda2.hid - 1,
-            limit=20,
-        )
-
-        tr_ids_in_graph = {n.id for n in graph.nodes if n.type == "tool_request"}
-        assert self._encode("r", tr1.id) in tr_ids_in_graph, "tr1 (producer of seed) must be present"
-        assert self._encode("r", tr2.id) in tr_ids_in_graph, "tr2 (consumer of seed) must be present"
-        assert self._encode("r", tr0.id) not in tr_ids_in_graph, (
-            "tr0 must NOT be present — closure pulled in hda1 as an item but must not "
-            "recursively pull in the producer of hda1"
-        )
-        assert self._encode("r", tr3.id) not in tr_ids_in_graph, (
-            "tr3 must NOT be present — closure pulled in hda3 as an item but must not "
-            "recursively pull in the consumer of hda3"
-        )
-        # Exactly the two tool_requests directly touching the seed.
-        assert len(tr_ids_in_graph) == 2
-
-        # Closure pulled in items beyond the single-item seed window.
-        assert graph.truncated.closure_items_added >= 2
-
-        # Closure cap did not fire (limit was generous).
-        assert graph.truncated.closure_capped is False
-
-    def test_closure_cap_removes_executions_not_items(self):
-        """Closure cap pruning removes executions, never items.
-
-        Constructs many consumer tool_requests on a single seed item,
-        each consuming/producing a unique extra item, so the closure
-        item count would explode.  With a tight closure cap, the
-        builder must:
-          - drop oldest non-sticky (consumer-only) trs first
-          - keep producer (sticky) trs
-          - report closure_capped=True
-        """
-        history, _ = self._create_history()
-        seed_hda = self._create_hda(history, name="seed")
-        # Producer of the seed item — sticky.
-        producer_tr = self._create_tool_request(history)
-        producer_job = self._create_job(tool_request=producer_tr, tool_id="producer")
-        producer_input = self._create_hda(history, name="producer_input")
-        self._link_job_input_hda(producer_job, producer_input)
-        self._link_job_output_hda(producer_job, seed_hda)
-
-        # Many consumer tool_requests, each with a unique output that
-        # closure would have to pull in.
-        consumer_trs = []
-        for i in range(5):
-            tr = self._create_tool_request(history)
-            job = self._create_job(tool_request=tr, tool_id=f"consumer_{i}")
-            self._link_job_input_hda(job, seed_hda)
-            extra_out = self._create_hda(history, name=f"consumer_{i}_out")
-            self._link_job_output_hda(job, extra_out)
-            consumer_trs.append(tr)
-
-        # Build with limit=1 → seed window holds one item, closure cap = 1.
-        # Closure would need to pull in producer_input + 5 consumer outputs = 6 items.
-        # Cap = 1 forces pruning of consumer trs (oldest first), keeping the
-        # sticky producer.
-        graph = self._build_graph(
-            history,
-            seed_scope=self._encode("d", seed_hda.id),
-            limit=1,
-        )
-
-        assert graph.truncated.closure_capped is True
-
-        kept_tr_ids = {n.id for n in graph.nodes if n.type == "tool_request"}
-        assert self._encode("r", producer_tr.id) in kept_tr_ids, (
-            "Sticky producer must survive closure cap pruning"
-        )
-
-        # At least some consumer trs were dropped.
-        kept_consumer_count = sum(
-            1 for tr in consumer_trs if self._encode("r", tr.id) in kept_tr_ids
-        )
-        assert kept_consumer_count < len(consumer_trs), (
-            "Some consumer tool_requests should have been pruned by the closure cap"
-        )
-
-        # Critical: every kept tool_request is structurally complete.
-        node_ids = {n.id for n in graph.nodes}
-        for tr_id in kept_tr_ids:
-            connected = {e.source for e in graph.edges if e.target == tr_id} | {
-                e.target for e in graph.edges if e.source == tr_id
-            }
-            for item in connected:
-                assert item in node_ids, (
-                    f"Closure cap pruning left tr {tr_id} pointing to missing item {item}"
-                )
-
     def test_pagination_newer_than_hid(self):
         """newer_than_hid selects only items with hid > N."""
         history, _ = self._create_history()
@@ -1433,49 +1214,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
             assert n.hid > boundary_hid, f"Node hid {n.hid} should be > {boundary_hid}"
         assert len(graph.nodes) == 3  # hdas[3], hdas[4], hdas[5]
 
-    def test_closure_completes_tool_requests_across_pagination(self):
-        """Closure rule under pagination: tool_requests crossing a
-        page boundary still appear with all their top-level inputs and
-        outputs.  The seed window stays unchanged
-        (oldest_hid_included/newest_hid_included describe the seed),
-        but closure expansion pulls in items outside the window.
-        """
-        history, _ = self._create_history()
-        input_hda = self._create_hda(history, name="input")
-        output_hda = self._create_hda(history, name="output")
-        tr = self._create_tool_request(history)
-        job = self._create_job(tool_request=tr, tool_id="boundary_tool")
-        self._link_job_input_hda(job, input_hda)
-        self._link_job_output_hda(job, output_hda)
-
-        # Full graph baseline: tool_request fully connected.
-        full = self._build_graph(history)
-        full_tr = [n for n in full.nodes if n.type == "tool_request"]
-        assert len(full_tr) == 1
-
-        # Page with only the older item (input).  Without closure the
-        # tool_request would be missing its output edge.  With closure
-        # the output item is pulled in.
-        graph = self._build_graph(history, older_than_hid=output_hda.hid)
-
-        tr_enc = self._encode("r", tr.id)
-        node_ids = {n.id for n in graph.nodes}
-        assert tr_enc in node_ids
-        assert self._encode("d", input_hda.id) in node_ids
-        assert self._encode("d", output_hda.id) in node_ids, (
-            "Output item should be pulled in by closure even though it is outside the seed window"
-        )
-
-        in_edges = [e for e in graph.edges if e.target == tr_enc and e.type == "dataset_input"]
-        out_edges = [e for e in graph.edges if e.source == tr_enc and e.type == "dataset_output"]
-        assert len(in_edges) == 1
-        assert len(out_edges) == 1
-
-        # oldest_hid_included still describes the SEED window (input only).
-        assert graph.truncated.newest_hid_included is not None
-        assert graph.truncated.newest_hid_included < output_hda.hid
-        assert graph.truncated.closure_items_added >= 1
-
     def test_stability_new_items_shift_recent_window(self):
         """Adding new items shifts the recent-overview window.
 
@@ -1607,9 +1345,22 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
         session.flush()
         return job
 
+    def _append_payload_input(self, job, ref):
+        if job.tool_request_id is None:
+            return
+        tr = self.trans.sa_session.get(model.ToolRequest, job.tool_request_id)
+        if tr is None:
+            return
+        payload = dict(tr.request) if isinstance(tr.request, dict) else {}
+        inputs = list(payload.get("inputs", []))
+        inputs.append(ref)
+        payload["inputs"] = inputs
+        tr.request = payload
+
     def _link_job_input_hda(self, job, hda, name="input"):
         assoc = model.JobToInputDatasetAssociation(name=name, dataset=hda)
         assoc.job_id = job.id
+        self._append_payload_input(job, {"src": "hda", "id": hda.id})
         self.trans.sa_session.add(assoc)
         self.trans.sa_session.flush()
 
@@ -1622,6 +1373,7 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
     def _link_job_input_hdca(self, job, hdca, name="input"):
         assoc = model.JobToInputDatasetCollectionAssociation(name=name, dataset_collection=hdca)
         assoc.job_id = job.id
+        self._append_payload_input(job, {"src": "hdca", "id": hdca.id})
         self.trans.sa_session.add(assoc)
         self.trans.sa_session.flush()
 
@@ -1682,12 +1434,11 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
 
         graph = self._build_graph(history, limit=limit)
 
-        # Items bounded by limit
+        # Items bounded by limit + closure (payload-driven closure can pull
+        # in at most one extra input per representable TR).
         item_nodes = [nd for nd in graph.nodes if nd.type != "tool_request"]
-        assert len(item_nodes) <= limit
-
-        # For linear chain: each full TR has 2 edges, partial TRs have 1
         tr_nodes = [nd for nd in graph.nodes if nd.type == "tool_request"]
+        assert len(item_nodes) <= limit + len(tr_nodes)
 
         # Each TR has at least one edge
         for tr_node in tr_nodes:
@@ -1846,40 +1597,6 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
         assert graph.truncated.newest_hid_included is not None
         assert graph.truncated.oldest_hid_included <= early.hid <= graph.truncated.newest_hid_included
 
-    def test_many_tool_requests_cap_enforced(self):
-        """Fan-out: each item connects to 3 TRs, exceeding the secondary TR cap.
-
-        The TR cap is limit × 2. With N items each connecting to 3 TRs,
-        discovered TRs = 3N > 2N = cap. Outputs are deleted so only the
-        original items are in scope, ensuring all fan-out TRs are discovered
-        from the input associations.
-        """
-        n_items = 100
-        history, _ = self._create_history()
-
-        # Create N visible items, each as input to 3 TRs
-        hdas = [self._create_hda(history, name=f"item_{i}") for i in range(n_items)]
-        for hda in hdas:
-            for j in range(3):
-                tr = self._create_tool_request(history)
-                job = self._create_job(tr, tool_id=f"fan_{j}")
-                self._link_job_input_hda(job, hda)
-                out = self._create_hda(history, name="fanout_out")
-                out.deleted = True  # Keep out of scope
-                self._link_job_output_hda(job, out)
-        self.trans.sa_session.flush()
-
-        # limit = n_items: all original items in scope.
-        # Discovered TRs = 300 (3 per item). Cap = 100 × 2 = 200. Triggers.
-        graph = self._build_graph(history, limit=n_items)
-
-        # TR cap enforced
-        tr_nodes = [nd for nd in graph.nodes if nd.type == "tool_request"]
-        assert len(tr_nodes) <= n_items * 2
-
-        # Secondary TR cap reported
-        assert graph.truncated.consumer_execution_capped is True
-
     def test_recent_overview_shift_after_append(self):
         """Recent overview shifts predictably when new items are appended.
 

From 8e283000d551b071cc052e7aa617695a3e9631ad Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Tue, 14 Apr 2026 13:58:15 +0300
Subject: [PATCH 09/28] Update comments

---
 lib/galaxy/managers/history_graph.py | 50 ++++++++++++++++------------
 1 file changed, 29 insertions(+), 21 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 64e9f2e742b..c77449e562c 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -2,9 +2,7 @@
 
 For each selected top-level history item, resolves its producing
 tool_request and that tool_request's declared inputs from the
-submission payload.  One hop only.  No consumers.  No transitive
-traversal.
-
+submission payload, one hop out from the seed.
 """
 
 import json
@@ -44,19 +42,27 @@ TYPE_RANK = {"dataset": 0, "collection": 1, "tool_request": 2}
 EDGE_TYPE_RANK = {"dataset_input": 0, "dataset_output": 1, "collection_input": 2, "collection_output": 3}
 NODE_TYPE_PREFIX = {"dataset": "d", "collection": "c", "tool_request": "r"}
 CHUNK = 1000
+MAX_LIMIT = 1000
 
 
 class HistoryGraphBuilder:
-    """Builds a bounded provenance graph from selected history items.
+    """Builds a provenance graph from selected history items.
 
-    Invariants enforced in code:
-    - HDA producer: JTODA only.  No Dataset.job_id fallback.
-    - HDCA producer: JODCA only.  No TRICA.  No HDCA.job_id.
-    - Inputs: tool_request.request payload only.  No job association tables.
-    - One hop.  No consumers.  No sibling outputs.  No transitive traversal.
-    - Ambiguity (≥2 distinct tool_request_ids): skip, log debug.
-    - Missing producer: no edge.
-    - Malformed payload: skip inputs.
+    Behaviors:
+    - HDA producer edges come from JobToOutputDatasetAssociation joined
+      to Job.
+    - HDCA producer edges come from JobToOutputDatasetCollectionAssociation
+      joined to Job.
+    - Input edges come from the tool_request.request submission payload.
+    - When an item resolves to more than one distinct producing
+      tool_request, the item is kept as a node and the producer edge is
+      skipped with a debug log.
+    - Malformed payloads are logged at debug level and the item becomes
+      a node with no input edges.
+    - Hidden HDAs that belong to a collection are filtered before
+      producer lookup and surfaced via their parent HDCA instead.
+    - ``limit`` is clamped to ``MAX_LIMIT`` to keep per-request work
+      bounded regardless of caller input.
     """
 
     def __init__(
@@ -77,7 +83,7 @@ class HistoryGraphBuilder:
         self.sa_session = sa_session
         self.security = security
         self.history_id = history_id
-        self.limit = limit
+        self.limit = min(limit, MAX_LIMIT)
         self.toolbox = toolbox
         self.include_deleted = include_deleted
         self.seed = seed
@@ -293,12 +299,13 @@ class HistoryGraphBuilder:
                 kept.add(row.id)
         return kept
 
-    # ── Producer lookup (strictly minimal) ──
+    # ── Producer lookup ──
 
     def _hda_producers(self, dataset_ids: set[int]) -> dict[tuple[str, int], tuple[int, str]]:
-        """JTODA only.  No Dataset.job_id.  No fallback.
-        Collect all candidates first, then emit only items with
-        exactly one distinct producer."""
+        """Resolve each HDA's producing (tool_request_id, tool_id) by
+        joining JobToOutputDatasetAssociation to Job. Only HDAs with
+        exactly one distinct producing tool_request are returned;
+        ambiguous ones are logged at debug level."""
         candidates: dict[int, dict[int, str]] = {}  # hda_id -> {tr_id: tool_id}
         for chunk in self._chunks(list(dataset_ids)):
             stmt = (
@@ -328,9 +335,10 @@ class HistoryGraphBuilder:
         return result
 
     def _hdca_producers(self, collection_ids: set[int]) -> dict[tuple[str, int], tuple[int, str]]:
-        """JODCA only.  No TRICA.  No HDCA.job_id.  No fallback.
-        Collect all candidates first, then emit only items with
-        exactly one distinct producer."""
+        """Resolve each HDCA's producing (tool_request_id, tool_id) by
+        joining JobToOutputDatasetCollectionAssociation to Job. Only
+        HDCAs with exactly one distinct producing tool_request are
+        returned; ambiguous ones are logged at debug level."""
         candidates: dict[int, dict[int, str]] = {}
         for chunk in self._chunks(list(collection_ids)):
             stmt = (
@@ -407,7 +415,7 @@ class HistoryGraphBuilder:
         return refs
 
     def _normalize_refs(self, refs: set[tuple[str, int]]) -> set[tuple[str, int]]:
-        """Single normalization rule: hidden-element HDA → parent HDCA."""
+        """Map hidden-element HDA refs in the payload to their parent HDCA."""
         result: set[tuple[str, int]] = set()
         hda_ids = [item_id for t, item_id in refs if t == "dataset"]
         hdca_parents: dict[int, int] = {}

From ee0b1a01c3f98bdb0a8bfa588372c3e6625ea1e0 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Tue, 14 Apr 2026 14:28:13 +0300
Subject: [PATCH 10/28] Use boltons.iterutils in tool input walker

---
 lib/galaxy/managers/history_graph.py | 50 +++++++++++++---------------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index c77449e562c..29dd71ec7f4 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -9,6 +9,7 @@ import json
 import logging
 from typing import Optional
 
+from boltons.iterutils import remap
 from sqlalchemy import (
     Select,
     select,
@@ -384,35 +385,30 @@ class HistoryGraphBuilder:
         return result
 
     def _extract_inputs(self, payload: dict) -> set[tuple[str, int]]:
-        """Extract and normalize input refs from a single payload."""
-        raw_refs = self._walk_payload(payload)
-        return self._normalize_refs(raw_refs)
+        """Walk a tool_request payload and return ``{(type, id)}`` refs,
+        with hidden element HDAs mapped to their parent HDCA.
 
-    @staticmethod
-    def _walk_payload(obj) -> set[tuple[str, int]]:
-        """Recursively extract {src, id} references.
-        Unknown src types are rejected with a DEBUG log."""
+        Uses the same ``boltons.iterutils.remap`` traversal idiom as
+        ``jobs.py::populate_input_data_input_id`` — when we hit a leaf
+        keyed ``id``, we peek at its sibling ``src`` on the parent
+        container to decide whether it is an HDA/HDCA reference."""
         refs: set[tuple[str, int]] = set()
-        if isinstance(obj, dict):
-            src = obj.get("src")
-            if src is not None:
-                item_id = obj.get("id")
-                if src in ("hda", "hdca") and isinstance(item_id, int):
-                    refs.add(("dataset" if src == "hda" else "collection", item_id))
-                else:
-                    log.debug("history_graph: rejected unknown payload ref src=%r id=%r", src, item_id)
-                return refs  # leaf ref node, do not recurse into src/id
-            if obj.get("__class__") == "Batch" and "values" in obj:
-                for v in obj["values"]:
-                    refs |= HistoryGraphBuilder._walk_payload(v)
-            else:
-                for k, v in obj.items():
-                    if k != "__class__":
-                        refs |= HistoryGraphBuilder._walk_payload(v)
-        elif isinstance(obj, list):
-            for item in obj:
-                refs |= HistoryGraphBuilder._walk_payload(item)
-        return refs
+
+        def visit(path, key, value):
+            if key == "id" and isinstance(value, int) and not isinstance(value, bool):
+                parent = payload
+                for step in path:
+                    parent = parent[step]
+                if isinstance(parent, dict):
+                    src = parent.get("src")
+                    if src == "hda":
+                        refs.add(("dataset", value))
+                    elif src == "hdca":
+                        refs.add(("collection", value))
+            return key, value
+
+        remap(payload, visit=visit)
+        return self._normalize_refs(refs)
 
     def _normalize_refs(self, refs: set[tuple[str, int]]) -> set[tuple[str, int]]:
         """Map hidden-element HDA refs in the payload to their parent HDCA."""

From efae7c6dab08d39fbe58573fbad2b7bea904b51d Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Tue, 14 Apr 2026 14:43:46 +0300
Subject: [PATCH 11/28] Add edge filter

---
 lib/galaxy/managers/history_graph.py | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 29dd71ec7f4..61e8e7bfb6e 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -165,9 +165,14 @@ class HistoryGraphBuilder:
         nodes.extend(self._collection_nodes(all_collection_ids))
         nodes.extend(self._tr_nodes(tr_nodes))
 
+        # Invariant: every edge endpoint must be a node. Edges were emitted
+        # before closure deletion filtering, so drop any that now reference
+        # an item that did not survive.
+        node_id_set = {n.id for n in nodes}
+        edges = [e for e in edges if e.source in node_id_set and e.target in node_id_set]
+
         # 5. Resolve tool names.
-        if self.toolbox:
-            self._resolve_tool_names(nodes)
+        self._resolve_tool_names(nodes)
 
         # 6. Optional seed subgraph filter (in-memory only).
         if self.seed:
@@ -391,7 +396,11 @@ class HistoryGraphBuilder:
         Uses the same ``boltons.iterutils.remap`` traversal idiom as
         ``jobs.py::populate_input_data_input_id`` — when we hit a leaf
         keyed ``id``, we peek at its sibling ``src`` on the parent
-        container to decide whether it is an HDA/HDCA reference."""
+        container to decide whether it is an HDA/HDCA reference.
+
+        Payload shape is trusted to be Pydantic-validated upstream when
+        the tool_request was accepted; no explicit depth or ref caps are
+        applied here by design."""
         refs: set[tuple[str, int]] = set()
 
         def visit(path, key, value):
@@ -517,11 +526,14 @@ class HistoryGraphBuilder:
         ]
 
     def _resolve_tool_names(self, nodes: list[GraphNode]):
+        toolbox = self.toolbox
+        if toolbox is None:
+            return
         tool_ids = {n.tool_id for n in nodes if n.type == "tool_request" and n.tool_id}
         name_map: dict[str, str] = {}
         for tool_id in tool_ids:
             try:
-                tool = self.toolbox.get_tool(tool_id)
+                tool = toolbox.get_tool(tool_id)
                 if tool and tool.name:
                     name_map[tool_id] = tool.name
             except Exception:

From 6fd6d66759f3c2d8799f374f39144a1061df0b37 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Tue, 14 Apr 2026 14:52:16 +0300
Subject: [PATCH 12/28] Reuse filtering, improve comments

---
 lib/galaxy/managers/history_graph.py | 59 ++++++++++++++++------------
 1 file changed, 33 insertions(+), 26 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 61e8e7bfb6e..ffa0c910a61 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -154,8 +154,10 @@ class HistoryGraphBuilder:
 
         # 4. Filter closure items by the same deleted policy as seed selection.
         if not self.include_deleted and (closure_dataset_ids or closure_collection_ids):
-            closure_dataset_ids = self._filter_deleted_hdas(closure_dataset_ids)
-            closure_collection_ids = self._filter_deleted_hdcas(closure_collection_ids)
+            closure_dataset_ids = self._filter_deleted_ids(HistoryDatasetAssociation, closure_dataset_ids)
+            closure_collection_ids = self._filter_deleted_ids(
+                HistoryDatasetCollectionAssociation, closure_collection_ids
+            )
 
         # Build nodes.
         all_dataset_ids = dataset_ids | closure_dataset_ids
@@ -279,27 +281,18 @@ class HistoryGraphBuilder:
                 to_remove.add(row.id)
         return dataset_ids - to_remove
 
-    def _filter_deleted_hdas(self, ids: set[int]) -> set[int]:
-        if not ids:
-            return ids
-        kept: set[int] = set()
-        for chunk in self._chunks(list(ids)):
-            stmt = select(HistoryDatasetAssociation.id).where(
-                HistoryDatasetAssociation.id.in_(chunk),
-                HistoryDatasetAssociation.deleted == False,  # noqa: E712
-            )
-            for row in self.sa_session.execute(stmt):
-                kept.add(row.id)
-        return kept
+    def _filter_deleted_ids(self, model_cls: type, ids: set[int]) -> set[int]:
+        """Return the subset of ``ids`` whose rows are not marked deleted.
 
-    def _filter_deleted_hdcas(self, ids: set[int]) -> set[int]:
+        Used to apply the seed-side deleted policy to closure items
+        pulled in via payload refs."""
         if not ids:
             return ids
         kept: set[int] = set()
         for chunk in self._chunks(list(ids)):
-            stmt = select(HistoryDatasetCollectionAssociation.id).where(
-                HistoryDatasetCollectionAssociation.id.in_(chunk),
-                HistoryDatasetCollectionAssociation.deleted == False,  # noqa: E712
+            stmt = select(model_cls.id).where(
+                model_cls.id.in_(chunk),
+                model_cls.deleted == False,  # noqa: E712
             )
             for row in self.sa_session.execute(stmt):
                 kept.add(row.id)
@@ -376,7 +369,11 @@ class HistoryGraphBuilder:
     # ── Payload input resolution ──
 
     def _fetch_payloads(self, tr_ids: set[int]) -> dict[int, dict]:
-        """Batch-fetch all tool_request.request payloads in one query."""
+        """Return raw ``tool_request.request`` payloads keyed by tool
+        request id.  Fetched in chunks of ``CHUNK`` ids. Rows whose
+        ``request`` field is not a dict (after decoding a JSON string
+        form) are silently dropped with a debug log, on the assumption
+        that a malformed payload contributes no usable input refs."""
         result: dict[int, dict] = {}
         for chunk in self._chunks(list(tr_ids)):
             stmt = select(ToolRequest.id, ToolRequest.request).where(ToolRequest.id.in_(chunk))
@@ -390,13 +387,19 @@ class HistoryGraphBuilder:
         return result
 
     def _extract_inputs(self, payload: dict) -> set[tuple[str, int]]:
-        """Walk a tool_request payload and return ``{(type, id)}`` refs,
-        with hidden element HDAs mapped to their parent HDCA.
+        """Sole payload entry point inside the builder. Walks a single
+        ``tool_request.request`` payload and returns the deduplicated
+        set of input refs the builder will emit edges for.
 
-        Uses the same ``boltons.iterutils.remap`` traversal idiom as
-        ``jobs.py::populate_input_data_input_id`` — when we hit a leaf
-        keyed ``id``, we peek at its sibling ``src`` on the parent
-        container to decide whether it is an HDA/HDCA reference.
+        Contract, in order:
+        1. Extract declared ``{src, id}`` refs from the payload, using
+           the same ``boltons.iterutils.remap`` traversal idiom as
+           ``jobs.py::populate_input_data_input_id`` — when we hit a
+           leaf keyed ``id``, we peek at its sibling ``src`` on the
+           parent container to decide whether it is an HDA/HDCA ref.
+        2. Normalize refs so that each one points at a top-level
+           history item (see ``_normalize_refs``).
+        3. Return as a set — the caller does not need to dedupe.
 
         Payload shape is trusted to be Pydantic-validated upstream when
         the tool_request was accepted; no explicit depth or ref caps are
@@ -420,7 +423,11 @@ class HistoryGraphBuilder:
         return self._normalize_refs(refs)
 
     def _normalize_refs(self, refs: set[tuple[str, int]]) -> set[tuple[str, int]]:
-        """Map hidden-element HDA refs in the payload to their parent HDCA."""
+        """Apply the single normalization rule: a hidden-element HDA
+        ref is replaced with its parent HDCA. Single-hop only — the
+        replacement is not re-normalized. No other rules apply here
+        by design; adding more cases should be weighed against the
+        invariant that every emitted ref points at a top-level item."""
         result: set[tuple[str, int]] = set()
         hda_ids = [item_id for t, item_id in refs if t == "dataset"]
         hdca_parents: dict[int, int] = {}

From 296d82d7f89d2ab9950b613218d1cee11918e21a Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Tue, 14 Apr 2026 17:53:47 +0300
Subject: [PATCH 13/28] Linting

---
 client/src/components/Workflow/Editor/Lint.vue        |  1 -
 .../src/components/Workflow/Editor/WorkflowGraph.vue  |  2 +-
 client/src/stores/workflowEditorStateStore.ts         |  2 +-
 lib/galaxy/managers/history_graph.py                  | 11 +++++++++--
 4 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/client/src/components/Workflow/Editor/Lint.vue b/client/src/components/Workflow/Editor/Lint.vue
index 1ff118aabd5..9ef0a845012 100644
--- a/client/src/components/Workflow/Editor/Lint.vue
+++ b/client/src/components/Workflow/Editor/Lint.vue
@@ -6,7 +6,6 @@ import type { DatatypesMapperModel } from "@/components/Datatypes/model";
 import { type ConfirmDialogOptions, useConfirmDialog } from "@/composables/confirmDialog";
 import { useWorkflowStores } from "@/composables/workflowStores";
 import type { Steps } from "@/stores/workflowStepStore";
-import type { Rectangle } from "@/utils/geometry";
 
 import {
     bestPracticeWarningAnnotation,
diff --git a/client/src/components/Workflow/Editor/WorkflowGraph.vue b/client/src/components/Workflow/Editor/WorkflowGraph.vue
index c4c0b54f76a..0023e6209b7 100644
--- a/client/src/components/Workflow/Editor/WorkflowGraph.vue
+++ b/client/src/components/Workflow/Editor/WorkflowGraph.vue
@@ -10,7 +10,7 @@ import { useWorkflowStores } from "@/composables/workflowStores";
 import type { TerminalPosition, XYPosition } from "@/stores/workflowEditorStateStore";
 import type { Step } from "@/stores/workflowStepStore";
 import { assertDefined } from "@/utils/assertions";
-import type { Rectangle, Vector } from "@/utils/geometry";
+import type { Vector } from "@/utils/geometry";
 
 import { useFocusedNodes } from "./composables/useFocusedNodes";
 import { useWorkflowBoundingBox } from "./composables/workflowBoundingBox";
diff --git a/client/src/stores/workflowEditorStateStore.ts b/client/src/stores/workflowEditorStateStore.ts
index 9818ce75e4d..8993fe48613 100644
--- a/client/src/stores/workflowEditorStateStore.ts
+++ b/client/src/stores/workflowEditorStateStore.ts
@@ -1,9 +1,9 @@
 import type { UseElementBoundingReturn } from "@vueuse/core";
 import { computed, reactive, ref, set, type UnwrapRef } from "vue";
 
-import type { Rectangle } from "@/components/Workflow/Editor/modules/geometry";
 import type { OutputTerminals } from "@/components/Workflow/Editor/modules/terminals";
 import reportDefault from "@/components/Workflow/Editor/reportDefault";
+import type { Rectangle } from "@/utils/geometry";
 
 import { defineScopedStore } from "./scopedStore";
 
diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index ffa0c910a61..27ed23fe110 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -7,7 +7,10 @@ submission payload, one hop out from the seed.
 
 import json
 import logging
-from typing import Optional
+from typing import (
+    Optional,
+    Union,
+)
 
 from boltons.iterutils import remap
 from sqlalchemy import (
@@ -281,7 +284,11 @@ class HistoryGraphBuilder:
                 to_remove.add(row.id)
         return dataset_ids - to_remove
 
-    def _filter_deleted_ids(self, model_cls: type, ids: set[int]) -> set[int]:
+    def _filter_deleted_ids(
+        self,
+        model_cls: Union[type[HistoryDatasetAssociation], type[HistoryDatasetCollectionAssociation]],
+        ids: set[int],
+    ) -> set[int]:
         """Return the subset of ``ids`` whose rows are not marked deleted.
 
         Used to apply the seed-side deleted policy to closure items

From e625f0f4a33c56997d6f2c5445f1183e15aa1fd6 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Wed, 15 Apr 2026 15:02:26 +0300
Subject: [PATCH 14/28] Drop chunking mechanism

---
 lib/galaxy/managers/history_graph.py | 255 +++++++++++++--------------
 1 file changed, 122 insertions(+), 133 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 27ed23fe110..fa6024b0365 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -45,7 +45,6 @@ log = logging.getLogger(__name__)
 TYPE_RANK = {"dataset": 0, "collection": 1, "tool_request": 2}
 EDGE_TYPE_RANK = {"dataset_input": 0, "dataset_output": 1, "collection_input": 2, "collection_output": 3}
 NODE_TYPE_PREFIX = {"dataset": "d", "collection": "c", "tool_request": "r"}
-CHUNK = 1000
 MAX_LIMIT = 1000
 
 
@@ -269,19 +268,16 @@ class HistoryGraphBuilder:
     def _remove_hidden_elements(self, dataset_ids: set[int]) -> set[int]:
         if not dataset_ids:
             return dataset_ids
-        to_remove: set[int] = set()
-        for chunk in self._chunks(list(dataset_ids)):
-            stmt = (
-                select(HistoryDatasetAssociation.id)
-                .join(DatasetCollectionElement, DatasetCollectionElement.hda_id == HistoryDatasetAssociation.id)
-                .where(
-                    HistoryDatasetAssociation.id.in_(chunk),
-                    HistoryDatasetAssociation.visible == False,  # noqa: E712
-                )
-                .distinct()
+        stmt = (
+            select(HistoryDatasetAssociation.id)
+            .join(DatasetCollectionElement, DatasetCollectionElement.hda_id == HistoryDatasetAssociation.id)
+            .where(
+                HistoryDatasetAssociation.id.in_(dataset_ids),
+                HistoryDatasetAssociation.visible == False,  # noqa: E712
             )
-            for row in self.sa_session.execute(stmt):
-                to_remove.add(row.id)
+            .distinct()
+        )
+        to_remove = {row.id for row in self.sa_session.execute(stmt)}
         return dataset_ids - to_remove
 
     def _filter_deleted_ids(
@@ -295,15 +291,11 @@ class HistoryGraphBuilder:
         pulled in via payload refs."""
         if not ids:
             return ids
-        kept: set[int] = set()
-        for chunk in self._chunks(list(ids)):
-            stmt = select(model_cls.id).where(
-                model_cls.id.in_(chunk),
-                model_cls.deleted == False,  # noqa: E712
-            )
-            for row in self.sa_session.execute(stmt):
-                kept.add(row.id)
-        return kept
+        stmt = select(model_cls.id).where(
+            model_cls.id.in_(ids),
+            model_cls.deleted == False,  # noqa: E712
+        )
+        return {row.id for row in self.sa_session.execute(stmt)}
 
     # ── Producer lookup ──
 
@@ -312,24 +304,25 @@ class HistoryGraphBuilder:
         joining JobToOutputDatasetAssociation to Job. Only HDAs with
         exactly one distinct producing tool_request are returned;
         ambiguous ones are logged at debug level."""
-        candidates: dict[int, dict[int, str]] = {}  # hda_id -> {tr_id: tool_id}
-        for chunk in self._chunks(list(dataset_ids)):
-            stmt = (
-                select(
-                    JobToOutputDatasetAssociation.dataset_id.label("hda_id"),
-                    Job.tool_request_id,
-                    Job.tool_id,
-                )
-                .join(Job, Job.id == JobToOutputDatasetAssociation.job_id)
-                .where(
-                    JobToOutputDatasetAssociation.dataset_id.in_(chunk),
-                    Job.tool_request_id.isnot(None),
-                    Job.tool_id.isnot(None),
-                    Job.tool_id != "__DATA_FETCH__",
-                )
+        if not dataset_ids:
+            return {}
+        stmt = (
+            select(
+                JobToOutputDatasetAssociation.dataset_id.label("hda_id"),
+                Job.tool_request_id,
+                Job.tool_id,
             )
-            for row in self.sa_session.execute(stmt):
-                candidates.setdefault(row.hda_id, {})[row.tool_request_id] = row.tool_id
+            .join(Job, Job.id == JobToOutputDatasetAssociation.job_id)
+            .where(
+                JobToOutputDatasetAssociation.dataset_id.in_(dataset_ids),
+                Job.tool_request_id.isnot(None),
+                Job.tool_id.isnot(None),
+                Job.tool_id != "__DATA_FETCH__",
+            )
+        )
+        candidates: dict[int, dict[int, str]] = {}  # hda_id -> {tr_id: tool_id}
+        for row in self.sa_session.execute(stmt):
+            candidates.setdefault(row.hda_id, {})[row.tool_request_id] = row.tool_id
 
         result: dict[tuple[str, int], tuple[int, str]] = {}
         for hda_id, tr_map in candidates.items():
@@ -345,24 +338,25 @@ class HistoryGraphBuilder:
         joining JobToOutputDatasetCollectionAssociation to Job. Only
         HDCAs with exactly one distinct producing tool_request are
         returned; ambiguous ones are logged at debug level."""
-        candidates: dict[int, dict[int, str]] = {}
-        for chunk in self._chunks(list(collection_ids)):
-            stmt = (
-                select(
-                    JobToOutputDatasetCollectionAssociation.dataset_collection_id.label("hdca_id"),
-                    Job.tool_request_id,
-                    Job.tool_id,
-                )
-                .join(Job, Job.id == JobToOutputDatasetCollectionAssociation.job_id)
-                .where(
-                    JobToOutputDatasetCollectionAssociation.dataset_collection_id.in_(chunk),
-                    Job.tool_request_id.isnot(None),
-                    Job.tool_id.isnot(None),
-                    Job.tool_id != "__DATA_FETCH__",
-                )
+        if not collection_ids:
+            return {}
+        stmt = (
+            select(
+                JobToOutputDatasetCollectionAssociation.dataset_collection_id.label("hdca_id"),
+                Job.tool_request_id,
+                Job.tool_id,
             )
-            for row in self.sa_session.execute(stmt):
-                candidates.setdefault(row.hdca_id, {})[row.tool_request_id] = row.tool_id
+            .join(Job, Job.id == JobToOutputDatasetCollectionAssociation.job_id)
+            .where(
+                JobToOutputDatasetCollectionAssociation.dataset_collection_id.in_(collection_ids),
+                Job.tool_request_id.isnot(None),
+                Job.tool_id.isnot(None),
+                Job.tool_id != "__DATA_FETCH__",
+            )
+        )
+        candidates: dict[int, dict[int, str]] = {}
+        for row in self.sa_session.execute(stmt):
+            candidates.setdefault(row.hdca_id, {})[row.tool_request_id] = row.tool_id
 
         result: dict[tuple[str, int], tuple[int, str]] = {}
         for hdca_id, tr_map in candidates.items():
@@ -377,20 +371,21 @@ class HistoryGraphBuilder:
 
     def _fetch_payloads(self, tr_ids: set[int]) -> dict[int, dict]:
         """Return raw ``tool_request.request`` payloads keyed by tool
-        request id.  Fetched in chunks of ``CHUNK`` ids. Rows whose
-        ``request`` field is not a dict (after decoding a JSON string
-        form) are silently dropped with a debug log, on the assumption
-        that a malformed payload contributes no usable input refs."""
+        request id. Rows whose ``request`` field is not a dict (after
+        decoding a JSON string form) are silently dropped with a debug
+        log, on the assumption that a malformed payload contributes no
+        usable input refs."""
+        if not tr_ids:
+            return {}
+        stmt = select(ToolRequest.id, ToolRequest.request).where(ToolRequest.id.in_(tr_ids))
         result: dict[int, dict] = {}
-        for chunk in self._chunks(list(tr_ids)):
-            stmt = select(ToolRequest.id, ToolRequest.request).where(ToolRequest.id.in_(chunk))
-            for row in self.sa_session.execute(stmt):
-                try:
-                    payload = json.loads(row.request) if isinstance(row.request, str) else row.request
-                    if isinstance(payload, dict):
-                        result[row.id] = payload
-                except (json.JSONDecodeError, TypeError):
-                    log.debug("history_graph: malformed payload for tool_request %d", row.id)
+        for row in self.sa_session.execute(stmt):
+            try:
+                payload = json.loads(row.request) if isinstance(row.request, str) else row.request
+                if isinstance(payload, dict):
+                    result[row.id] = payload
+            except (json.JSONDecodeError, TypeError):
+                log.debug("history_graph: malformed payload for tool_request %d", row.id)
         return result
 
     def _extract_inputs(self, payload: dict) -> set[tuple[str, int]]:
@@ -435,10 +430,9 @@ class HistoryGraphBuilder:
         replacement is not re-normalized. No other rules apply here
         by design; adding more cases should be weighed against the
         invariant that every emitted ref points at a top-level item."""
-        result: set[tuple[str, int]] = set()
         hda_ids = [item_id for t, item_id in refs if t == "dataset"]
         hdca_parents: dict[int, int] = {}
-        for chunk in self._chunks(hda_ids):
+        if hda_ids:
             stmt = (
                 select(
                     HistoryDatasetAssociation.id.label("hda_id"),
@@ -450,13 +444,14 @@ class HistoryGraphBuilder:
                     HistoryDatasetCollectionAssociation.collection_id == DatasetCollectionElement.dataset_collection_id,
                 )
                 .where(
-                    HistoryDatasetAssociation.id.in_(chunk),
+                    HistoryDatasetAssociation.id.in_(hda_ids),
                     HistoryDatasetAssociation.visible == False,  # noqa: E712
                 )
             )
             for row in self.sa_session.execute(stmt):
                 hdca_parents[row.hda_id] = row.hdca_id
 
+        result: set[tuple[str, int]] = set()
         for ref_type, ref_id in refs:
             if ref_type == "dataset" and ref_id in hdca_parents:
                 result.add(("collection", hdca_parents[ref_id]))
@@ -467,67 +462,65 @@ class HistoryGraphBuilder:
     # ── Node construction ──
 
     def _dataset_nodes(self, db_ids: set[int]) -> list[GraphNode]:
-        nodes = []
-        for chunk in self._chunks(list(db_ids)):
-            stmt = (
-                select(
-                    HistoryDatasetAssociation.id,
-                    HistoryDatasetAssociation.name,
-                    HistoryDatasetAssociation.hid,
-                    HistoryDatasetAssociation._state,
-                    Dataset.state.label("dataset_state"),
-                    HistoryDatasetAssociation.extension,
-                    HistoryDatasetAssociation.deleted,
-                    HistoryDatasetAssociation.visible,
-                )
-                .join(Dataset, HistoryDatasetAssociation.dataset_id == Dataset.id)
-                .where(HistoryDatasetAssociation.id.in_(chunk))
+        if not db_ids:
+            return []
+        stmt = (
+            select(
+                HistoryDatasetAssociation.id,
+                HistoryDatasetAssociation.name,
+                HistoryDatasetAssociation.hid,
+                HistoryDatasetAssociation._state,
+                Dataset.state.label("dataset_state"),
+                HistoryDatasetAssociation.extension,
+                HistoryDatasetAssociation.deleted,
+                HistoryDatasetAssociation.visible,
             )
-            for row in self.sa_session.execute(stmt):
-                nodes.append(
-                    GraphNode(
-                        id=self._encode("dataset", row.id),
-                        type="dataset",
-                        name=row.name,
-                        hid=row.hid,
-                        state=row._state if row._state else row.dataset_state,
-                        extension=row.extension,
-                        deleted=row.deleted,
-                        visible=row.visible,
-                    )
-                )
-        return nodes
+            .join(Dataset, HistoryDatasetAssociation.dataset_id == Dataset.id)
+            .where(HistoryDatasetAssociation.id.in_(db_ids))
+        )
+        return [
+            GraphNode(
+                id=self._encode("dataset", row.id),
+                type="dataset",
+                name=row.name,
+                hid=row.hid,
+                state=row._state if row._state else row.dataset_state,
+                extension=row.extension,
+                deleted=row.deleted,
+                visible=row.visible,
+            )
+            for row in self.sa_session.execute(stmt)
+        ]
 
     def _collection_nodes(self, db_ids: set[int]) -> list[GraphNode]:
-        nodes = []
-        for chunk in self._chunks(list(db_ids)):
-            stmt = (
-                select(
-                    HistoryDatasetCollectionAssociation.id,
-                    HistoryDatasetCollectionAssociation.name,
-                    HistoryDatasetCollectionAssociation.hid,
-                    HistoryDatasetCollectionAssociation.deleted,
-                    HistoryDatasetCollectionAssociation.visible,
-                    DatasetCollection.collection_type,
-                    DatasetCollection.populated_state,
-                )
-                .join(DatasetCollection, HistoryDatasetCollectionAssociation.collection_id == DatasetCollection.id)
-                .where(HistoryDatasetCollectionAssociation.id.in_(chunk))
+        if not db_ids:
+            return []
+        stmt = (
+            select(
+                HistoryDatasetCollectionAssociation.id,
+                HistoryDatasetCollectionAssociation.name,
+                HistoryDatasetCollectionAssociation.hid,
+                HistoryDatasetCollectionAssociation.deleted,
+                HistoryDatasetCollectionAssociation.visible,
+                DatasetCollection.collection_type,
+                DatasetCollection.populated_state,
             )
-            for row in self.sa_session.execute(stmt):
-                nodes.append(
-                    GraphNode(
-                        id=self._encode("collection", row.id),
-                        type="collection",
-                        name=row.name,
-                        hid=row.hid,
-                        state=row.populated_state,
-                        collection_type=row.collection_type,
-                        deleted=row.deleted,
-                        visible=row.visible,
-                    )
-                )
-        return nodes
+            .join(DatasetCollection, HistoryDatasetCollectionAssociation.collection_id == DatasetCollection.id)
+            .where(HistoryDatasetCollectionAssociation.id.in_(db_ids))
+        )
+        return [
+            GraphNode(
+                id=self._encode("collection", row.id),
+                type="collection",
+                name=row.name,
+                hid=row.hid,
+                state=row.populated_state,
+                collection_type=row.collection_type,
+                deleted=row.deleted,
+                visible=row.visible,
+            )
+            for row in self.sa_session.execute(stmt)
+        ]
 
     def _tr_nodes(self, tr_map: dict[int, Optional[str]]) -> list[GraphNode]:
         return [
@@ -611,7 +604,3 @@ class HistoryGraphBuilder:
         encoded = f"{NODE_TYPE_PREFIX[node_type]}{self.security.encode_id(db_id)}"
         self._sort_keys[encoded] = (TYPE_RANK[node_type], db_id)
         return encoded
-
-    @staticmethod
-    def _chunks(items: list) -> list[list]:
-        return [items[i : i + CHUNK] for i in range(0, len(items), CHUNK)] if items else []

From 87fe6be8c1ca7819a1ab6ae3c15e4ed31533b7ff Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Wed, 15 Apr 2026 15:31:18 +0300
Subject: [PATCH 15/28] Deduplication set for edges is unnecessary

---
 lib/galaxy/managers/history_graph.py | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index fa6024b0365..dcbc5ed2a51 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -125,17 +125,13 @@ class HistoryGraphBuilder:
         all_producers = {**hda_producers, **hdca_producers}
 
         # Emit output edges and collect tr_ids.
-        seen_edges: set[tuple[str, str, str]] = set()
         for item_key, (tr_id, tool_id) in all_producers.items():
             item_type, item_id = item_key
             tr_nodes[tr_id] = tool_id
             src = self._encode("tool_request", tr_id)
             tgt = self._encode(item_type, item_id)
             etype = "dataset_output" if item_type == "dataset" else "collection_output"
-            edge_key = (src, tgt, etype)
-            if edge_key not in seen_edges:
-                seen_edges.add(edge_key)
-                edges.append(GraphEdge(source=src, target=tgt, type=etype))
+            edges.append(GraphEdge(source=src, target=tgt, type=etype))
 
         # Batch-fetch all payloads, parse inputs, emit input edges.
         payloads = self._fetch_payloads(set(tr_nodes.keys()))
@@ -145,10 +141,7 @@ class HistoryGraphBuilder:
                 src = self._encode(ref_type, ref_id)
                 tgt = self._encode("tool_request", tr_id)
                 etype = "dataset_input" if ref_type == "dataset" else "collection_input"
-                edge_key = (src, tgt, etype)
-                if edge_key not in seen_edges:
-                    seen_edges.add(edge_key)
-                    edges.append(GraphEdge(source=src, target=tgt, type=etype))
+                edges.append(GraphEdge(source=src, target=tgt, type=etype))
                 if ref_type == "dataset" and ref_id not in dataset_ids:
                     closure_dataset_ids.add(ref_id)
                 elif ref_type == "collection" and ref_id not in collection_ids:

From 4fd1cbee4f0e001d85159bf0a2bc8c0dcb227ef0 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Wed, 15 Apr 2026 16:19:19 +0300
Subject: [PATCH 16/28] Remove hid window interface from api

---
 lib/galaxy/managers/history_graph.py          |  49 +++----
 lib/galaxy/schema/history_graph.py            |   4 +-
 lib/galaxy/webapps/galaxy/api/histories.py    |  12 +-
 .../webapps/galaxy/services/histories.py      |   4 -
 .../app/managers/test_HistoryGraphBuilder.py  | 132 +-----------------
 5 files changed, 27 insertions(+), 174 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index dcbc5ed2a51..086d5f65b2e 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -79,8 +79,6 @@ class HistoryGraphBuilder:
         seed: Optional[str] = None,
         direction: str = "both",
         depth: int = 5,
-        older_than_hid: Optional[int] = None,
-        newer_than_hid: Optional[int] = None,
         seed_scope: Optional[str] = None,
     ):
         self.sa_session = sa_session
@@ -92,9 +90,9 @@ class HistoryGraphBuilder:
         self.seed = seed
         self.direction = direction
         self.depth = depth
-        self.older_than_hid = older_than_hid
-        self.newer_than_hid = newer_than_hid
         self.seed_scope = seed_scope
+        self._older_than_hid: Optional[int] = None
+        self._newer_than_hid: Optional[int] = None
         self._sort_keys: dict[str, tuple[int, int]] = {}
 
     def build(self) -> HistoryGraphResponse:
@@ -102,14 +100,10 @@ class HistoryGraphBuilder:
         if self.seed_scope:
             truncation.scope_type = "seed_centered"
             self._resolve_seed_scope()
-        elif self.older_than_hid is not None or self.newer_than_hid is not None:
-            truncation.scope_type = "window"
 
         # 1. Select top-level items in scope.
-        dataset_ids, collection_ids, item_capped, oldest_hid, newest_hid = self._select_items()
+        dataset_ids, collection_ids, item_capped = self._select_items()
         truncation.item_count_capped = item_capped
-        truncation.oldest_hid_included = oldest_hid
-        truncation.newest_hid_included = newest_hid
 
         # 2. Remove hidden collection elements.
         dataset_ids = self._remove_hidden_elements(dataset_ids)
@@ -202,10 +196,10 @@ class HistoryGraphBuilder:
         if row is None or row.hid is None:
             raise RequestParameterInvalidException(f"seed_scope {self.seed_scope} not found in history.")
         half = self.limit // 2
-        self.older_than_hid = row.hid + half + (self.limit % 2)
-        self.newer_than_hid = row.hid - half - 1
+        self._older_than_hid = row.hid + half + (self.limit % 2)
+        self._newer_than_hid = row.hid - half - 1
 
-    def _select_items(self) -> tuple[set[int], set[int], bool, Optional[int], Optional[int]]:
+    def _select_items(self) -> tuple[set[int], set[int], bool]:
         hda_q: Select = select(
             HistoryDatasetAssociation.id,
             HistoryDatasetAssociation.hid,
@@ -213,10 +207,10 @@ class HistoryGraphBuilder:
         ).where(HistoryDatasetAssociation.history_id == self.history_id)
         if not self.include_deleted:
             hda_q = hda_q.where(HistoryDatasetAssociation.deleted == False)  # noqa: E712
-        if self.older_than_hid is not None:
-            hda_q = hda_q.where(HistoryDatasetAssociation.hid < self.older_than_hid)
-        if self.newer_than_hid is not None:
-            hda_q = hda_q.where(HistoryDatasetAssociation.hid > self.newer_than_hid)
+        if self._older_than_hid is not None:
+            hda_q = hda_q.where(HistoryDatasetAssociation.hid < self._older_than_hid)
+        if self._newer_than_hid is not None:
+            hda_q = hda_q.where(HistoryDatasetAssociation.hid > self._newer_than_hid)
 
         hdca_q: Select = select(
             HistoryDatasetCollectionAssociation.id,
@@ -225,22 +219,23 @@ class HistoryGraphBuilder:
         ).where(HistoryDatasetCollectionAssociation.history_id == self.history_id)
         if not self.include_deleted:
             hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.deleted == False)  # noqa: E712
-        if self.older_than_hid is not None:
-            hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.hid < self.older_than_hid)
-        if self.newer_than_hid is not None:
-            hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.hid > self.newer_than_hid)
+        if self._older_than_hid is not None:
+            hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.hid < self._older_than_hid)
+        if self._newer_than_hid is not None:
+            hdca_q = hdca_q.where(HistoryDatasetCollectionAssociation.hid > self._newer_than_hid)
 
         combined = union_all(hda_q, hdca_q).subquery()
+        # Deterministic order: hid desc, then id desc as a stable tiebreaker
+        # so duplicate hids (theoretically possible across imported data) do
+        # not affect internal selection stability.
         stmt = (
             select(combined.c.id, combined.c.hid, combined.c.item_type)
-            .order_by(combined.c.hid.desc())
+            .order_by(combined.c.hid.desc(), combined.c.id.desc())
             .limit(self.limit + 1)
         )
 
         dataset_ids: set[int] = set()
         collection_ids: set[int] = set()
-        min_hid: Optional[int] = None
-        max_hid: Optional[int] = None
         count = 0
         for row in self.sa_session.execute(stmt):
             count += 1
@@ -250,13 +245,7 @@ class HistoryGraphBuilder:
                 dataset_ids.add(row.id)
             else:
                 collection_ids.add(row.id)
-            hid = row.hid
-            if hid is not None:
-                if min_hid is None or hid < min_hid:
-                    min_hid = hid
-                if max_hid is None or hid > max_hid:
-                    max_hid = hid
-        return dataset_ids, collection_ids, count > self.limit, min_hid, max_hid
+        return dataset_ids, collection_ids, count > self.limit
 
     def _remove_hidden_elements(self, dataset_ids: set[int]) -> set[int]:
         if not dataset_ids:
diff --git a/lib/galaxy/schema/history_graph.py b/lib/galaxy/schema/history_graph.py
index d791214c9e5..a85e2e8f945 100644
--- a/lib/galaxy/schema/history_graph.py
+++ b/lib/galaxy/schema/history_graph.py
@@ -28,9 +28,7 @@ class GraphEdge(BaseModel):
 
 class TruncationInfo(BaseModel):
     item_count_capped: bool = False
-    scope_type: Literal["recent", "window", "seed_centered"] = "recent"
-    oldest_hid_included: Optional[int] = None
-    newest_hid_included: Optional[int] = None
+    scope_type: Literal["recent", "seed_centered"] = "recent"
     seed_in_scope: Optional[bool] = None
 
 
diff --git a/lib/galaxy/webapps/galaxy/api/histories.py b/lib/galaxy/webapps/galaxy/api/histories.py
index d9fcd06b02c..2c11ed3857d 100644
--- a/lib/galaxy/webapps/galaxy/api/histories.py
+++ b/lib/galaxy/webapps/galaxy/api/histories.py
@@ -390,17 +390,9 @@ class FastAPIHistories:
             ge=1,
             le=20,
         ),
-        older_than_hid: Optional[int] = Query(
-            default=None,
-            description="Pagination: select items with hid less than this value (older items).",
-        ),
-        newer_than_hid: Optional[int] = Query(
-            default=None,
-            description="Pagination: select items with hid greater than this value (newer items).",
-        ),
         seed_scope: Optional[str] = Query(
             default=None,
-            description="Center the selection window on this item's hid position. Format: d{encoded_id} or c{encoded_id}.",
+            description="Center the selection window on this item. Format: d{encoded_id} or c{encoded_id}.",
         ),
         trans: ProvidesHistoryContext = DependsOnTrans,
     ) -> HistoryGraphResponse:
@@ -412,8 +404,6 @@ class FastAPIHistories:
             seed=seed,
             direction=direction,
             depth=depth,
-            older_than_hid=older_than_hid,
-            newer_than_hid=newer_than_hid,
             seed_scope=seed_scope,
         )
 
diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index d0da29f9474..d7ce3a2184a 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -389,8 +389,6 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
         seed: Optional[str] = None,
         direction: str = "both",
         depth: int = 20,
-        older_than_hid: Optional[int] = None,
-        newer_than_hid: Optional[int] = None,
         seed_scope: Optional[str] = None,
     ):
         history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
@@ -405,8 +403,6 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
             seed=seed,
             direction=direction,
             depth=depth,
-            older_than_hid=older_than_hid,
-            newer_than_hid=newer_than_hid,
             seed_scope=seed_scope,
         )
         return builder.build()
diff --git a/test/unit/app/managers/test_HistoryGraphBuilder.py b/test/unit/app/managers/test_HistoryGraphBuilder.py
index 8642776b310..d0e54a366d3 100644
--- a/test/unit/app/managers/test_HistoryGraphBuilder.py
+++ b/test/unit/app/managers/test_HistoryGraphBuilder.py
@@ -43,8 +43,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         direction="both",
         depth=20,
         limit=500,
-        older_than_hid=None,
-        newer_than_hid=None,
         seed_scope=None,
     ):
         builder = HistoryGraphBuilder(
@@ -55,8 +53,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
             seed=seed,
             direction=direction,
             depth=depth,
-            older_than_hid=older_than_hid,
-            newer_than_hid=newer_than_hid,
             seed_scope=seed_scope,
         )
         return builder.build()
@@ -194,8 +190,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         assert len(graph.nodes) == 0
         assert len(graph.edges) == 0
         assert graph.truncated.scope_type == "recent"
-        assert graph.truncated.oldest_hid_included is None
-        assert graph.truncated.newest_hid_included is None
         assert graph.truncated.seed_in_scope is None
 
     def test_standalone_datasets_included(self):
@@ -206,9 +200,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         graph = self._build_graph(history)
         assert len(graph.nodes) == 2
         assert len(graph.edges) == 0
-        assert graph.truncated.oldest_hid_included is not None
-        assert graph.truncated.newest_hid_included is not None
-        assert graph.truncated.newest_hid_included >= graph.truncated.oldest_hid_included
 
     def test_full_history_graph(self):
         """Full history graph includes all items and edges."""
@@ -413,7 +404,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
             assert e.source != e.target, f"Self-loop: {e.source}"
 
     def test_seed_scope_centers_on_item(self):
-        """seed_scope centers the selection window on the specified item's hid."""
+        """seed_scope centers the selection window on the specified item."""
         history, _ = self._create_history()
         # Create 10 standalone datasets
         hdas = [self._create_hda(history, name=f"dataset_{i}") for i in range(10)]
@@ -427,19 +418,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         # The seed item must be in scope
         node_ids = {n.id for n in graph.nodes}
         assert seed_scope in node_ids
-        # Scope metadata should reflect the window
         assert graph.truncated.scope_type == "seed_centered"
-        assert graph.truncated.oldest_hid_included is not None
-        assert graph.truncated.newest_hid_included is not None
-        assert graph.truncated.oldest_hid_included <= middle.hid <= graph.truncated.newest_hid_included
-
-    def test_pagination_scope_type(self):
-        """Pagination params produce scope_type='window'."""
-        history, _ = self._create_history()
-        for i in range(5):
-            self._create_hda(history, name=f"dataset_{i}")
-        graph = self._build_graph(history, older_than_hid=4)
-        assert graph.truncated.scope_type == "window"
 
     def test_seed_in_scope_true(self):
         """seed_in_scope is true when seed is in the constructed graph."""
@@ -625,24 +604,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         graph = builder.build()
         assert len(graph.nodes) == 1
 
-    def test_pagination_no_overlap(self):
-        """Consecutive pages share no items."""
-        history, _ = self._create_history()
-        for i in range(10):
-            self._create_hda(history, name=f"ds_{i}")
-
-        # Page 1: most recent 5
-        page1 = self._build_graph(history, limit=5)
-        page1_ids = {n.id for n in page1.nodes}
-        oldest_hid = page1.truncated.oldest_hid_included
-
-        # Page 2: older than page 1's oldest
-        page2 = self._build_graph(history, limit=5, older_than_hid=oldest_hid)
-        page2_ids = {n.id for n in page2.nodes}
-
-        assert len(page1_ids & page2_ids) == 0, "Pages must not overlap"
-        assert len(page1_ids) + len(page2_ids) == 10
-
     def test_determinism_identical_requests(self):
         """Identical requests produce identical output."""
         history, _ = self._create_history()
@@ -1174,9 +1135,11 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         # 5-step chain: hda0 → tr0 → hda1 → tr1 → hda2 → tr2 → hda3 → tr3 → hda4 → tr4 → hda5
         chain = self._build_linear_chain(history, length=5)
 
-        # Pick a small seed window in the middle of the chain.
-        middle_input_hid = chain[2][0].hid
-        graph = self._build_graph(history, older_than_hid=middle_input_hid + 1, newer_than_hid=middle_input_hid - 1)
+        # Center the seed window on the middle hda with limit=1, so the
+        # window holds just that one item and closure must complete the
+        # tool_request from there.
+        middle_hda = chain[2][0]
+        graph = self._build_graph(history, seed_scope=self._encode("d", middle_hda.id), limit=1)
 
         node_ids = {n.id for n in graph.nodes}
         tr_nodes = [n for n in graph.nodes if n.type == "tool_request"]
@@ -1198,22 +1161,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
                 "expected at least one input and one output after closure"
             )
 
-    def test_pagination_newer_than_hid(self):
-        """newer_than_hid selects only items with hid > N."""
-        history, _ = self._create_history()
-        hdas = [self._create_hda(history, name=f"ds_{i}") for i in range(6)]
-
-        # Get the middle item's hid as boundary
-        boundary_hid = hdas[2].hid
-
-        graph = self._build_graph(history, newer_than_hid=boundary_hid)
-
-        # Only items with hid > boundary_hid should be included
-        for n in graph.nodes:
-            assert n.hid is not None
-            assert n.hid > boundary_hid, f"Node hid {n.hid} should be > {boundary_hid}"
-        assert len(graph.nodes) == 3  # hdas[3], hdas[4], hdas[5]
-
     def test_stability_new_items_shift_recent_window(self):
         """Adding new items shifts the recent-overview window.
 
@@ -1242,29 +1189,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         for hda in original[1:]:
             assert self._encode("d", hda.id) in ids2
 
-    def test_stability_hid_window_does_not_mutate(self):
-        """A fixed hid-based window returns the same results even after new items are added."""
-        history, _ = self._create_history()
-        for i in range(5):
-            self._create_hda(history, name=f"ds_{i}")
-
-        # Take a snapshot with older_than_hid to define a fixed window
-        snapshot = self._build_graph(history, older_than_hid=4)
-        snapshot_ids = {n.id for n in snapshot.nodes}
-        snapshot_hids = sorted(n.hid for n in snapshot.nodes if n.hid is not None)
-
-        # Add new items to the history (higher hids)
-        for i in range(5, 10):
-            self._create_hda(history, name=f"ds_{i}")
-
-        # Same window query returns identical results
-        after = self._build_graph(history, older_than_hid=4)
-        after_ids = {n.id for n in after.nodes}
-        after_hids = sorted(n.hid for n in after.nodes if n.hid is not None)
-
-        assert snapshot_ids == after_ids
-        assert snapshot_hids == after_hids
-
 
 # ── Scalability / Boundedness Tests ──
 
@@ -1409,9 +1333,6 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
         assert len(graph.nodes) == min(n, limit)
         assert len(graph.edges) == 0
         assert graph.truncated.item_count_capped == (n > limit)
-        assert graph.truncated.oldest_hid_included is not None
-        assert graph.truncated.newest_hid_included is not None
-        assert graph.truncated.oldest_hid_included <= graph.truncated.newest_hid_included
 
     def test_deep_linear_chain(self):
         """N-step linear chain: A→tr→B→tr→C→...
@@ -1530,42 +1451,6 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
         # Total edge count bounded: not m*k element edges
         assert len(graph.edges) <= 2 * len(tr_nodes)
 
-    def test_pagination_non_overlapping_windows(self):
-        """Two consecutive pages on a large history.
-
-        Assert: no overlap, deterministic ordering, expected hid ranges.
-        """
-        n = GRAPH_SCALE_HISTORY_SIZE
-        limit = n // 2
-        history, _ = self._create_history()
-        for i in range(n):
-            self._create_hda(history, name=f"ds_{i}")
-
-        # Page 1: most recent
-        page1 = self._build_graph(history, limit=limit)
-        page1_ids = {nd.id for nd in page1.nodes}
-        page1_hids = sorted(nd.hid for nd in page1.nodes if nd.hid is not None)
-
-        assert len(page1.nodes) == limit
-        assert page1.truncated.item_count_capped is True
-        oldest_hid_p1 = page1.truncated.oldest_hid_included
-
-        # Page 2: older items
-        page2 = self._build_graph(history, limit=limit, older_than_hid=oldest_hid_p1)
-        page2_ids = {nd.id for nd in page2.nodes}
-        page2_hids = sorted(nd.hid for nd in page2.nodes if nd.hid is not None)
-
-        # No overlap
-        assert len(page1_ids & page2_ids) == 0, "Pages must not overlap"
-
-        # Deterministic ordering: page1 has higher hids than page2
-        if page1_hids and page2_hids:
-            assert min(page1_hids) > max(page2_hids), "Page 1 should contain newer items than page 2"
-
-        # Expected hid ranges
-        assert page1.truncated.newest_hid_included >= page1.truncated.oldest_hid_included
-        assert page2.truncated.newest_hid_included >= page2.truncated.oldest_hid_included
-
     def test_seed_scope_on_older_item(self):
         """seed_scope on an early item in a large history.
 
@@ -1590,12 +1475,7 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
 
         # Response bounded
         assert len(graph.nodes) <= limit
-
-        # Scope metadata valid
         assert graph.truncated.scope_type == "seed_centered"
-        assert graph.truncated.oldest_hid_included is not None
-        assert graph.truncated.newest_hid_included is not None
-        assert graph.truncated.oldest_hid_included <= early.hid <= graph.truncated.newest_hid_included
 
     def test_recent_overview_shift_after_append(self):
         """Recent overview shifts predictably when new items are appended.

From 6cbc941242e2caaf4f23ba8fd4b5a4910df48cd6 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Wed, 15 Apr 2026 16:30:45 +0300
Subject: [PATCH 17/28] Validate seed on api level

---
 lib/galaxy/managers/history_graph.py       | 32 ++++++++++------------
 lib/galaxy/webapps/galaxy/api/histories.py |  1 +
 2 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 086d5f65b2e..1dd88fc9c4a 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -99,7 +99,7 @@ class HistoryGraphBuilder:
         truncation = TruncationInfo()
         if self.seed_scope:
             truncation.scope_type = "seed_centered"
-            self._resolve_seed_scope()
+            self._resolve_seed_scope(self.seed_scope)
 
         # 1. Select top-level items in scope.
         dataset_ids, collection_ids, item_capped = self._select_items()
@@ -169,7 +169,7 @@ class HistoryGraphBuilder:
         if self.seed:
             node_ids = {n.id for n in nodes}
             truncation.seed_in_scope = self.seed in node_ids
-            nodes, edges = self._seed_filter(nodes, edges)
+            nodes, edges = self._seed_filter(self.seed, nodes, edges)
 
         # 7. Sort.
         nodes, edges = self._sort(nodes, edges)
@@ -177,24 +177,20 @@ class HistoryGraphBuilder:
 
     # ── Item selection ──
 
-    def _resolve_seed_scope(self):
+    def _resolve_seed_scope(self, seed_scope: str):
         from galaxy.exceptions import RequestParameterInvalidException
 
-        if not self.seed_scope or len(self.seed_scope) < 2:
-            raise RequestParameterInvalidException(f"Invalid seed_scope: {self.seed_scope!r}")
-        prefix = self.seed_scope[0]
-        if prefix not in ("d", "c"):
-            raise RequestParameterInvalidException(f"Invalid seed_scope prefix: {prefix!r}")
+        prefix = seed_scope[0]
         try:
-            db_id = self.security.decode_id(self.seed_scope[1:])
+            db_id = self.security.decode_id(seed_scope[1:])
         except Exception:
-            raise RequestParameterInvalidException(f"Invalid seed_scope encoding: {self.seed_scope!r}")
+            raise RequestParameterInvalidException(f"Invalid seed_scope encoding: {seed_scope!r}")
         model = HistoryDatasetAssociation if prefix == "d" else HistoryDatasetCollectionAssociation
         row = self.sa_session.execute(
             select(model.hid).where(model.id == db_id, model.history_id == self.history_id)
         ).first()
         if row is None or row.hid is None:
-            raise RequestParameterInvalidException(f"seed_scope {self.seed_scope} not found in history.")
+            raise RequestParameterInvalidException(f"seed_scope {seed_scope} not found in history.")
         half = self.limit // 2
         self._older_than_hid = row.hid + half + (self.limit % 2)
         self._newer_than_hid = row.hid - half - 1
@@ -533,14 +529,14 @@ class HistoryGraphBuilder:
 
     # ── Seed subgraph filter (in-memory only) ──
 
-    def _seed_filter(self, nodes: list[GraphNode], edges: list[GraphEdge]) -> tuple[list[GraphNode], list[GraphEdge]]:
+    def _seed_filter(
+        self, seed: str, nodes: list[GraphNode], edges: list[GraphEdge]
+    ) -> tuple[list[GraphNode], list[GraphEdge]]:
         from galaxy.exceptions import RequestParameterInvalidException
 
-        if not self.seed or len(self.seed) < 2:
-            raise RequestParameterInvalidException(f"Invalid seed: {self.seed!r}")
         node_ids = {n.id for n in nodes}
-        if self.seed not in node_ids:
-            raise RequestParameterInvalidException(f"Seed {self.seed} not found in graph.")
+        if seed not in node_ids:
+            raise RequestParameterInvalidException(f"Seed {seed} not found in graph.")
 
         out_map: dict[str, set[str]] = {}
         in_map: dict[str, set[str]] = {}
@@ -548,8 +544,8 @@ class HistoryGraphBuilder:
             out_map.setdefault(e.source, set()).add(e.target)
             in_map.setdefault(e.target, set()).add(e.source)
 
-        reachable: set[str] = {self.seed}
-        frontier = {self.seed}
+        reachable: set[str] = {seed}
+        frontier = {seed}
         for _ in range(self.depth):
             nxt: set[str] = set()
             for nid in frontier:
diff --git a/lib/galaxy/webapps/galaxy/api/histories.py b/lib/galaxy/webapps/galaxy/api/histories.py
index 2c11ed3857d..5e91e0b8883 100644
--- a/lib/galaxy/webapps/galaxy/api/histories.py
+++ b/lib/galaxy/webapps/galaxy/api/histories.py
@@ -393,6 +393,7 @@ class FastAPIHistories:
         seed_scope: Optional[str] = Query(
             default=None,
             description="Center the selection window on this item. Format: d{encoded_id} or c{encoded_id}.",
+            pattern=r"^[dc].+$",
         ),
         trans: ProvidesHistoryContext = DependsOnTrans,
     ) -> HistoryGraphResponse:

From 68fb22e3b960ac03b66782e4265251f74c7d31b8 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Wed, 15 Apr 2026 22:52:55 +0300
Subject: [PATCH 18/28] Add tests

---
 client/src/api/schema/schema.ts       |  12 +--
 lib/galaxy_test/api/test_histories.py | 102 ++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 10 deletions(-)

diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index 8a66eab194f..59fad0a910b 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -23802,16 +23802,12 @@ export interface components {
              * @default false
              */
             item_count_capped: boolean;
-            /** Newest Hid Included */
-            newest_hid_included?: number | null;
-            /** Oldest Hid Included */
-            oldest_hid_included?: number | null;
             /**
              * Scope Type
              * @default recent
              * @enum {string}
              */
-            scope_type: "recent" | "window" | "seed_centered";
+            scope_type: "recent" | "seed_centered";
             /** Seed In Scope */
             seed_in_scope?: boolean | null;
         };
@@ -39247,11 +39243,7 @@ export interface operations {
                 direction?: "backward" | "forward" | "both";
                 /** @description Max depth for seed-based subgraph extraction. */
                 depth?: number;
-                /** @description Pagination: select items with hid less than this value (older items). */
-                older_than_hid?: number | null;
-                /** @description Pagination: select items with hid greater than this value (newer items). */
-                newer_than_hid?: number | null;
-                /** @description Center the selection window on this item's hid position. Format: d{encoded_id} or c{encoded_id}. */
+                /** @description Center the selection window on this item. Format: d{encoded_id} or c{encoded_id}. */
                 seed_scope?: string | null;
             };
             header?: {
diff --git a/lib/galaxy_test/api/test_histories.py b/lib/galaxy_test/api/test_histories.py
index 8d33169484b..0a55789cf19 100644
--- a/lib/galaxy_test/api/test_histories.py
+++ b/lib/galaxy_test/api/test_histories.py
@@ -3,6 +3,7 @@ from typing import ClassVar
 from unittest import SkipTest
 from uuid import uuid4
 
+import pytest
 from requests import put
 
 from galaxy.model.unittest_utils.store_fixtures import (
@@ -1247,3 +1248,104 @@ class TestArchivingHistoriesWithoutExportRecord(ApiTestCase, BaseHistories):
         histories = self.dataset_populator.get_histories()
         for history in histories:
             assert history["id"] != history_id
+
+
+class TestHistoryGraphApi(ApiTestCase, BaseHistories):
+    """API-level tests for ``GET /api/histories/{id}/graph``.
+
+    These cover the surface the endpoint owns: status codes, query
+    parameter validation, auth boundaries, and response shape. Builder
+    logic is exercised separately in ``test_HistoryGraphBuilder``.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.dataset_populator = DatasetPopulator(self.galaxy_interactor)
+
+    # ── response shape ──
+
+    def test_empty_history_returns_empty_graph(self):
+        history_id = self.dataset_populator.new_history()
+        response = self._get(f"histories/{history_id}/graph")
+        self._assert_status_code_is(response, 200)
+        body = response.json()
+        self._assert_has_keys(body, "nodes", "edges", "truncated")
+        assert body["nodes"] == []
+        assert body["edges"] == []
+        assert body["truncated"]["item_count_capped"] is False
+        assert body["truncated"]["scope_type"] == "recent"
+
+    def test_standalone_datasets_appear_as_dataset_nodes(self):
+        history_id = self.dataset_populator.new_history()
+        self.dataset_populator.new_dataset(history_id, content="a", wait=True)
+        self.dataset_populator.new_dataset(history_id, content="b", wait=True)
+        response = self._get(f"histories/{history_id}/graph")
+        self._assert_status_code_is(response, 200)
+        body = response.json()
+        assert len(body["nodes"]) == 2
+        assert body["edges"] == []
+        assert all(n["type"] == "dataset" for n in body["nodes"])
+
+    def test_limit_caps_items_and_sets_truncation_flag(self):
+        history_id = self.dataset_populator.new_history()
+        for i in range(5):
+            self.dataset_populator.new_dataset(history_id, content=f"row {i}", wait=True)
+        response = self._get(f"histories/{history_id}/graph", data={"limit": 3})
+        self._assert_status_code_is(response, 200)
+        body = response.json()
+        assert len(body["nodes"]) == 3
+        assert body["truncated"]["item_count_capped"] is True
+
+    def test_seed_scope_returns_seed_centered_window(self):
+        history_id = self.dataset_populator.new_history()
+        dataset = self.dataset_populator.new_dataset(history_id, content="seed", wait=True)
+        seed_scope = f"d{dataset['id']}"
+        response = self._get(
+            f"histories/{history_id}/graph",
+            data={"seed_scope": seed_scope, "limit": 5},
+        )
+        self._assert_status_code_is(response, 200)
+        body = response.json()
+        assert body["truncated"]["scope_type"] == "seed_centered"
+        assert seed_scope in {n["id"] for n in body["nodes"]}
+
+    # ── query-parameter validation (API-layer regex and bounds) ──
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [
+            ("seed_scope", "xabc"),  # wrong prefix
+            ("seed_scope", "d"),  # prefix but empty body
+            ("seed", "z"),  # wrong prefix
+            ("limit", 5000),  # above max
+            ("depth", 21),  # above max
+        ],
+    )
+    def test_invalid_query_params_return_400(self, param, value):
+        history_id = self.dataset_populator.new_history()
+        response = self._get(f"histories/{history_id}/graph", data={param: value})
+        self._assert_status_code_is(response, 400)
+
+    # ── manager-level validation (after API regex passes) ──
+
+    def test_seed_scope_not_in_target_history_is_rejected(self):
+        source_history = self.dataset_populator.new_history()
+        dataset = self.dataset_populator.new_dataset(source_history, content="a", wait=True)
+        target_history = self.dataset_populator.new_history()
+        response = self._get(
+            f"histories/{target_history}/graph",
+            data={"seed_scope": f"d{dataset['id']}"},
+        )
+        assert 400 <= response.status_code < 500
+
+    # ── auth ──
+
+    def test_other_users_history_is_forbidden(self):
+        with self._different_user():
+            other_history_id = self.dataset_populator.new_history()
+        response = self._get(f"histories/{other_history_id}/graph")
+        self._assert_status_code_is(response, 403)
+
+    def test_nonexistent_history_is_rejected(self):
+        response = self._get("histories/0000000000000000/graph")
+        assert 400 <= response.status_code < 500

From e36d726cd0df519e092d9f59028488722dcb5e65 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Fri, 1 May 2026 21:48:52 +0300
Subject: [PATCH 19/28] Move test helpers to populator

---
 lib/galaxy_test/api/test_histories.py | 30 +++++++--------------------
 lib/galaxy_test/base/populators.py    |  8 +++++++
 2 files changed, 16 insertions(+), 22 deletions(-)

diff --git a/lib/galaxy_test/api/test_histories.py b/lib/galaxy_test/api/test_histories.py
index 0a55789cf19..a733d5004c2 100644
--- a/lib/galaxy_test/api/test_histories.py
+++ b/lib/galaxy_test/api/test_histories.py
@@ -1266,9 +1266,7 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
 
     def test_empty_history_returns_empty_graph(self):
         history_id = self.dataset_populator.new_history()
-        response = self._get(f"histories/{history_id}/graph")
-        self._assert_status_code_is(response, 200)
-        body = response.json()
+        body = self.dataset_populator.get_history_graph(history_id)
         self._assert_has_keys(body, "nodes", "edges", "truncated")
         assert body["nodes"] == []
         assert body["edges"] == []
@@ -1279,9 +1277,7 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
         history_id = self.dataset_populator.new_history()
         self.dataset_populator.new_dataset(history_id, content="a", wait=True)
         self.dataset_populator.new_dataset(history_id, content="b", wait=True)
-        response = self._get(f"histories/{history_id}/graph")
-        self._assert_status_code_is(response, 200)
-        body = response.json()
+        body = self.dataset_populator.get_history_graph(history_id)
         assert len(body["nodes"]) == 2
         assert body["edges"] == []
         assert all(n["type"] == "dataset" for n in body["nodes"])
@@ -1290,9 +1286,7 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
         history_id = self.dataset_populator.new_history()
         for i in range(5):
             self.dataset_populator.new_dataset(history_id, content=f"row {i}", wait=True)
-        response = self._get(f"histories/{history_id}/graph", data={"limit": 3})
-        self._assert_status_code_is(response, 200)
-        body = response.json()
+        body = self.dataset_populator.get_history_graph(history_id, limit=3)
         assert len(body["nodes"]) == 3
         assert body["truncated"]["item_count_capped"] is True
 
@@ -1300,12 +1294,7 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
         history_id = self.dataset_populator.new_history()
         dataset = self.dataset_populator.new_dataset(history_id, content="seed", wait=True)
         seed_scope = f"d{dataset['id']}"
-        response = self._get(
-            f"histories/{history_id}/graph",
-            data={"seed_scope": seed_scope, "limit": 5},
-        )
-        self._assert_status_code_is(response, 200)
-        body = response.json()
+        body = self.dataset_populator.get_history_graph(history_id, seed_scope=seed_scope, limit=5)
         assert body["truncated"]["scope_type"] == "seed_centered"
         assert seed_scope in {n["id"] for n in body["nodes"]}
 
@@ -1323,7 +1312,7 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
     )
     def test_invalid_query_params_return_400(self, param, value):
         history_id = self.dataset_populator.new_history()
-        response = self._get(f"histories/{history_id}/graph", data={param: value})
+        response = self.dataset_populator.get_history_graph_raw(history_id, **{param: value})
         self._assert_status_code_is(response, 400)
 
     # ── manager-level validation (after API regex passes) ──
@@ -1332,10 +1321,7 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
         source_history = self.dataset_populator.new_history()
         dataset = self.dataset_populator.new_dataset(source_history, content="a", wait=True)
         target_history = self.dataset_populator.new_history()
-        response = self._get(
-            f"histories/{target_history}/graph",
-            data={"seed_scope": f"d{dataset['id']}"},
-        )
+        response = self.dataset_populator.get_history_graph_raw(target_history, seed_scope=f"d{dataset['id']}")
         assert 400 <= response.status_code < 500
 
     # ── auth ──
@@ -1343,9 +1329,9 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
     def test_other_users_history_is_forbidden(self):
         with self._different_user():
             other_history_id = self.dataset_populator.new_history()
-        response = self._get(f"histories/{other_history_id}/graph")
+        response = self.dataset_populator.get_history_graph_raw(other_history_id)
         self._assert_status_code_is(response, 403)
 
     def test_nonexistent_history_is_rejected(self):
-        response = self._get("histories/0000000000000000/graph")
+        response = self.dataset_populator.get_history_graph_raw("0000000000000000")
         assert 400 <= response.status_code < 500
diff --git a/lib/galaxy_test/base/populators.py b/lib/galaxy_test/base/populators.py
index 28e08baba91..6a47db225a1 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -1842,6 +1842,14 @@ class BaseDatasetPopulator(BasePopulator):
         api_asserts.assert_status_code_is_ok(response)
         return response.json()
 
+    def get_history_graph(self, history_id: str, **params: Any) -> dict[str, Any]:
+        response = self.get_history_graph_raw(history_id, **params)
+        api_asserts.assert_status_code_is_ok(response)
+        return response.json()
+
+    def get_history_graph_raw(self, history_id: str, **params: Any) -> Response:
+        return self._get(f"histories/{history_id}/graph", data=params or None)
+
     def wait_on_task(self, async_task_response: Response):
         response_json = async_task_response.json()
         return self.wait_on_task_object(response_json)

From ea9f27b4aa8b34a26a960d50062a1729892d420e Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Fri, 1 May 2026 21:50:54 +0300
Subject: [PATCH 20/28] Move import to top-level

---
 lib/galaxy/managers/history_graph.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 1dd88fc9c4a..7e87319217a 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -21,6 +21,7 @@ from sqlalchemy import (
 from sqlalchemy.orm import Session
 from sqlalchemy.sql.expression import literal_column
 
+from galaxy.exceptions import RequestParameterInvalidException
 from galaxy.model import (
     Dataset,
     DatasetCollection,
@@ -178,8 +179,6 @@ class HistoryGraphBuilder:
     # ── Item selection ──
 
     def _resolve_seed_scope(self, seed_scope: str):
-        from galaxy.exceptions import RequestParameterInvalidException
-
         prefix = seed_scope[0]
         try:
             db_id = self.security.decode_id(seed_scope[1:])
@@ -532,8 +531,6 @@ class HistoryGraphBuilder:
     def _seed_filter(
         self, seed: str, nodes: list[GraphNode], edges: list[GraphEdge]
     ) -> tuple[list[GraphNode], list[GraphEdge]]:
-        from galaxy.exceptions import RequestParameterInvalidException
-
         node_ids = {n.id for n in nodes}
         if seed not in node_ids:
             raise RequestParameterInvalidException(f"Seed {seed} not found in graph.")

From 55b7e61047be5d0ea1887d8a726fca4c01afaa56 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Fri, 1 May 2026 21:52:32 +0300
Subject: [PATCH 21/28] Access toolbox directly, no need for get attribute

---
 lib/galaxy/webapps/galaxy/services/histories.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index d7ce3a2184a..db65240104d 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -392,13 +392,12 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
         seed_scope: Optional[str] = None,
     ):
         history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
-        toolbox = getattr(trans.app, "toolbox", None)
         builder = HistoryGraphBuilder(
             sa_session=trans.sa_session,
             security=self.security,
             history_id=history.id,
             limit=limit,
-            toolbox=toolbox,
+            toolbox=trans.app.toolbox,
             include_deleted=include_deleted,
             seed=seed,
             direction=direction,

From 3ce0edd6174f67994832f1cce1ec5aec10f5d384 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Fri, 1 May 2026 22:18:13 +0300
Subject: [PATCH 22/28] Move remaining validation to service layer

---
 lib/galaxy/managers/history_graph.py          | 26 ++++----------
 .../webapps/galaxy/services/histories.py      | 18 ++++++++--
 .../app/managers/test_HistoryGraphBuilder.py  | 34 +++++--------------
 3 files changed, 31 insertions(+), 47 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 7e87319217a..3ee42d75e0c 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -80,7 +80,7 @@ class HistoryGraphBuilder:
         seed: Optional[str] = None,
         direction: str = "both",
         depth: int = 5,
-        seed_scope: Optional[str] = None,
+        seed_scope_hid: Optional[int] = None,
     ):
         self.sa_session = sa_session
         self.security = security
@@ -91,16 +91,18 @@ class HistoryGraphBuilder:
         self.seed = seed
         self.direction = direction
         self.depth = depth
-        self.seed_scope = seed_scope
+        self.seed_scope_hid = seed_scope_hid
         self._older_than_hid: Optional[int] = None
         self._newer_than_hid: Optional[int] = None
         self._sort_keys: dict[str, tuple[int, int]] = {}
 
     def build(self) -> HistoryGraphResponse:
         truncation = TruncationInfo()
-        if self.seed_scope:
+        if self.seed_scope_hid is not None:
             truncation.scope_type = "seed_centered"
-            self._resolve_seed_scope(self.seed_scope)
+            half = self.limit // 2
+            self._older_than_hid = self.seed_scope_hid + half + (self.limit % 2)
+            self._newer_than_hid = self.seed_scope_hid - half - 1
 
         # 1. Select top-level items in scope.
         dataset_ids, collection_ids, item_capped = self._select_items()
@@ -178,22 +180,6 @@ class HistoryGraphBuilder:
 
     # ── Item selection ──
 
-    def _resolve_seed_scope(self, seed_scope: str):
-        prefix = seed_scope[0]
-        try:
-            db_id = self.security.decode_id(seed_scope[1:])
-        except Exception:
-            raise RequestParameterInvalidException(f"Invalid seed_scope encoding: {seed_scope!r}")
-        model = HistoryDatasetAssociation if prefix == "d" else HistoryDatasetCollectionAssociation
-        row = self.sa_session.execute(
-            select(model.hid).where(model.id == db_id, model.history_id == self.history_id)
-        ).first()
-        if row is None or row.hid is None:
-            raise RequestParameterInvalidException(f"seed_scope {seed_scope} not found in history.")
-        half = self.limit // 2
-        self._older_than_hid = row.hid + half + (self.limit % 2)
-        self._newer_than_hid = row.hid - half - 1
-
     def _select_items(self) -> tuple[set[int], set[int], bool]:
         hda_q: Select = select(
             HistoryDatasetAssociation.id,
diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index db65240104d..3c92fb34f8e 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -42,7 +42,10 @@ from galaxy.managers.histories import (
 )
 from galaxy.managers.history_graph import HistoryGraphBuilder
 from galaxy.managers.users import UserManager
-from galaxy.model import HistoryDatasetAssociation
+from galaxy.model import (
+    HistoryDatasetAssociation,
+    HistoryDatasetCollectionAssociation,
+)
 from galaxy.model.scoped_session import galaxy_scoped_session
 from galaxy.model.store import payload_to_source_uri
 from galaxy.schema import (
@@ -392,6 +395,7 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
         seed_scope: Optional[str] = None,
     ):
         history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
+        seed_scope_hid = self._resolve_seed_scope_hid(trans, history.id, seed_scope) if seed_scope else None
         builder = HistoryGraphBuilder(
             sa_session=trans.sa_session,
             security=self.security,
@@ -402,10 +406,20 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
             seed=seed,
             direction=direction,
             depth=depth,
-            seed_scope=seed_scope,
+            seed_scope_hid=seed_scope_hid,
         )
         return builder.build()
 
+    def _resolve_seed_scope_hid(self, trans: ProvidesHistoryContext, history_id: int, seed_scope: str) -> int:
+        db_id = self.security.decode_id(seed_scope[1:])
+        model_class = HistoryDatasetAssociation if seed_scope[0] == "d" else HistoryDatasetCollectionAssociation
+        row = trans.sa_session.execute(
+            select(model_class.hid).where(model_class.id == db_id, model_class.history_id == history_id)
+        ).first()
+        if row is None or row.hid is None:
+            raise glx_exceptions.ObjectNotFound(f"seed_scope {seed_scope} not found in history.")
+        return row.hid
+
     def prepare_download(
         self, trans: ProvidesHistoryContext, history_id: DecodedDatabaseIdField, payload: StoreExportPayload
     ) -> AsyncFile:
diff --git a/test/unit/app/managers/test_HistoryGraphBuilder.py b/test/unit/app/managers/test_HistoryGraphBuilder.py
index d0e54a366d3..fe5256a248b 100644
--- a/test/unit/app/managers/test_HistoryGraphBuilder.py
+++ b/test/unit/app/managers/test_HistoryGraphBuilder.py
@@ -43,7 +43,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         direction="both",
         depth=20,
         limit=500,
-        seed_scope=None,
+        seed_scope_hid=None,
     ):
         builder = HistoryGraphBuilder(
             sa_session=self.trans.sa_session,
@@ -53,7 +53,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
             seed=seed,
             direction=direction,
             depth=depth,
-            seed_scope=seed_scope,
+            seed_scope_hid=seed_scope_hid,
         )
         return builder.build()
 
@@ -404,20 +404,19 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
             assert e.source != e.target, f"Self-loop: {e.source}"
 
     def test_seed_scope_centers_on_item(self):
-        """seed_scope centers the selection window on the specified item."""
+        """seed_scope_hid centers the selection window on the specified hid."""
         history, _ = self._create_history()
         # Create 10 standalone datasets
         hdas = [self._create_hda(history, name=f"dataset_{i}") for i in range(10)]
 
-        # Use seed_scope to center on the middle item (limit=4 → should get ~4 items around it)
+        # Center on the middle item (limit=4 → should get ~4 items around it)
         middle = hdas[5]
-        seed_scope = self._encode("d", middle.id)
-        graph = self._build_graph(history, seed_scope=seed_scope, limit=4)
+        graph = self._build_graph(history, seed_scope_hid=middle.hid, limit=4)
 
         assert len(graph.nodes) <= 4
         # The seed item must be in scope
         node_ids = {n.id for n in graph.nodes}
-        assert seed_scope in node_ids
+        assert self._encode("d", middle.id) in node_ids
         assert graph.truncated.scope_type == "seed_centered"
 
     def test_seed_in_scope_true(self):
@@ -436,20 +435,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         graph = self._build_graph(history)
         assert graph.truncated.seed_in_scope is None
 
-    def test_seed_scope_not_found(self):
-        """seed_scope with nonexistent item returns 422."""
-        history, _ = self._create_history()
-        self._create_hda(history, name="dataset")
-        fake_scope = f"d{self.app.security.encode_id(99999)}"
-        with pytest.raises(RequestParameterInvalidException):
-            self._build_graph(history, seed_scope=fake_scope)
-
-    def test_seed_scope_invalid_prefix(self):
-        """seed_scope with invalid prefix returns 422."""
-        history, _ = self._create_history()
-        with pytest.raises(RequestParameterInvalidException):
-            self._build_graph(history, seed_scope="x_invalid")
-
     # ── Step 5: Validation tests ──
 
     def test_map_over_input_edges(self):
@@ -1139,7 +1124,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         # window holds just that one item and closure must complete the
         # tool_request from there.
         middle_hda = chain[2][0]
-        graph = self._build_graph(history, seed_scope=self._encode("d", middle_hda.id), limit=1)
+        graph = self._build_graph(history, seed_scope_hid=middle_hda.hid, limit=1)
 
         node_ids = {n.id for n in graph.nodes}
         tr_nodes = [n for n in graph.nodes if n.type == "tool_request"]
@@ -1465,13 +1450,12 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
 
         # Pick an early item (10th from the beginning)
         early = hdas[9]
-        seed_scope = self._encode("d", early.id)
 
-        graph = self._build_graph(history, seed_scope=seed_scope, limit=limit)
+        graph = self._build_graph(history, seed_scope_hid=early.hid, limit=limit)
 
         # Seed item must be in scope
         node_ids = {nd.id for nd in graph.nodes}
-        assert seed_scope in node_ids
+        assert self._encode("d", early.id) in node_ids
 
         # Response bounded
         assert len(graph.nodes) <= limit

From 748fef123b9a67d73c80674f70369410b990756f Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Fri, 1 May 2026 22:47:52 +0300
Subject: [PATCH 23/28] Fix typing use AbstractToolBox

---
 lib/galaxy/managers/history_graph.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 3ee42d75e0c..57a8994318a 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -21,7 +21,10 @@ from sqlalchemy import (
 from sqlalchemy.orm import Session
 from sqlalchemy.sql.expression import literal_column
 
-from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.exceptions import (
+    MessageException,
+    RequestParameterInvalidException,
+)
 from galaxy.model import (
     Dataset,
     DatasetCollection,
@@ -40,6 +43,7 @@ from galaxy.schema.history_graph import (
     TruncationInfo,
 )
 from galaxy.security.idencoding import IdEncodingHelper
+from galaxy.tool_util.toolbox import AbstractToolBox
 
 log = logging.getLogger(__name__)
 
@@ -75,7 +79,7 @@ class HistoryGraphBuilder:
         security: IdEncodingHelper,
         history_id: int,
         limit: int = 500,
-        toolbox=None,
+        toolbox: Optional[AbstractToolBox] = None,
         include_deleted: bool = False,
         seed: Optional[str] = None,
         direction: str = "both",
@@ -495,7 +499,7 @@ class HistoryGraphBuilder:
             for tr_id, tool_id in tr_map.items()
         ]
 
-    def _resolve_tool_names(self, nodes: list[GraphNode]):
+    def _resolve_tool_names(self, nodes: list[GraphNode]) -> None:
         toolbox = self.toolbox
         if toolbox is None:
             return
@@ -506,7 +510,7 @@ class HistoryGraphBuilder:
                 tool = toolbox.get_tool(tool_id)
                 if tool and tool.name:
                     name_map[tool_id] = tool.name
-            except Exception:
+            except MessageException:
                 pass
         for node in nodes:
             if node.type == "tool_request" and node.tool_id and node.tool_id in name_map:

From 00e9721d564f182b9da93d13457902f0e4ba2415 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Fri, 1 May 2026 22:55:41 +0300
Subject: [PATCH 24/28] Tighten graph endpoint typing and pin 404 in API tests

- direction: Literal["backward","forward","both"] in service and manager
- HistoriesService.graph annotated -> HistoryGraphResponse
- Pin 404 for missing seed_scope and missing history (was loose 4xx)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 lib/galaxy/managers/history_graph.py            | 3 ++-
 lib/galaxy/webapps/galaxy/services/histories.py | 5 +++--
 lib/galaxy_test/api/test_histories.py           | 4 ++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 57a8994318a..5e1e5766e3f 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -8,6 +8,7 @@ submission payload, one hop out from the seed.
 import json
 import logging
 from typing import (
+    Literal,
     Optional,
     Union,
 )
@@ -82,7 +83,7 @@ class HistoryGraphBuilder:
         toolbox: Optional[AbstractToolBox] = None,
         include_deleted: bool = False,
         seed: Optional[str] = None,
-        direction: str = "both",
+        direction: Literal["backward", "forward", "both"] = "both",
         depth: int = 5,
         seed_scope_hid: Optional[int] = None,
     ):
diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index 3c92fb34f8e..fd18c61b7db 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -54,6 +54,7 @@ from galaxy.schema import (
 )
 from galaxy.schema.fields import DecodedDatabaseIdField
 from galaxy.schema.history import HistoryIndexQueryPayload
+from galaxy.schema.history_graph import HistoryGraphResponse
 from galaxy.schema.schema import (
     AnyArchivedHistoryView,
     AnyHistoryView,
@@ -390,10 +391,10 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
         limit: int = 500,
         include_deleted: bool = False,
         seed: Optional[str] = None,
-        direction: str = "both",
+        direction: Literal["backward", "forward", "both"] = "both",
         depth: int = 20,
         seed_scope: Optional[str] = None,
-    ):
+    ) -> HistoryGraphResponse:
         history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
         seed_scope_hid = self._resolve_seed_scope_hid(trans, history.id, seed_scope) if seed_scope else None
         builder = HistoryGraphBuilder(
diff --git a/lib/galaxy_test/api/test_histories.py b/lib/galaxy_test/api/test_histories.py
index a733d5004c2..53bfc672638 100644
--- a/lib/galaxy_test/api/test_histories.py
+++ b/lib/galaxy_test/api/test_histories.py
@@ -1322,7 +1322,7 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
         dataset = self.dataset_populator.new_dataset(source_history, content="a", wait=True)
         target_history = self.dataset_populator.new_history()
         response = self.dataset_populator.get_history_graph_raw(target_history, seed_scope=f"d{dataset['id']}")
-        assert 400 <= response.status_code < 500
+        self._assert_status_code_is(response, 404)
 
     # ── auth ──
 
@@ -1334,4 +1334,4 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
 
     def test_nonexistent_history_is_rejected(self):
         response = self.dataset_populator.get_history_graph_raw("0000000000000000")
-        assert 400 <= response.status_code < 500
+        self._assert_status_code_is(response, 404)

From 10a0b8a5567a049f367611600f29d2fd6c36cad9 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Fri, 1 May 2026 23:01:10 +0300
Subject: [PATCH 25/28] Clean up history graph builder test suite

- Replace global _user_counter with uuid4().hex[:8] for xdist safety
- Drop test_determinism_identical_requests (duplicate of test_deterministic_ordering)
- Lift inline imports (sqlalchemy event, HistoryGraphBuilder) to top
- Lower scale defaults (500/100/10/50 -> 250/60/5/20)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../app/managers/test_HistoryGraphBuilder.py  | 35 +++++--------------
 1 file changed, 9 insertions(+), 26 deletions(-)

diff --git a/test/unit/app/managers/test_HistoryGraphBuilder.py b/test/unit/app/managers/test_HistoryGraphBuilder.py
index fe5256a248b..c6d3b6fffc0 100644
--- a/test/unit/app/managers/test_HistoryGraphBuilder.py
+++ b/test/unit/app/managers/test_HistoryGraphBuilder.py
@@ -1,6 +1,8 @@
 import os
+from uuid import uuid4
 
 import pytest
+from sqlalchemy import event
 
 from galaxy import model
 from galaxy.exceptions import RequestParameterInvalidException
@@ -15,15 +17,13 @@ from .base import (
 )
 
 default_password = "123456"
-_user_counter = 0
 
 
 def _next_user_data():
-    global _user_counter
-    _user_counter += 1
+    suffix = uuid4().hex[:8]
     return dict(
-        email=f"graphuser{_user_counter}@test.test",
-        username=f"graphuser{_user_counter}",
+        email=f"graphuser{suffix}@test.test",
+        username=f"graphuser{suffix}",
         password=default_password,
     )
 
@@ -589,19 +589,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         graph = builder.build()
         assert len(graph.nodes) == 1
 
-    def test_determinism_identical_requests(self):
-        """Identical requests produce identical output."""
-        history, _ = self._create_history()
-        self._build_linear_chain(history, length=3)
-
-        graph1 = self._build_graph(history)
-        graph2 = self._build_graph(history)
-
-        assert [n.id for n in graph1.nodes] == [n.id for n in graph2.nodes]
-        assert [(e.source, e.target, e.type) for e in graph1.edges] == [
-            (e.source, e.target, e.type) for e in graph2.edges
-        ]
-
     def test_expanding_limit_generally_additive(self):
         """Expanding limit is generally additive for standalone datasets.
 
@@ -996,8 +983,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         This is the deliberately conservative behavior — we do not pick
         an arbitrary winner at the response level.
         """
-        from galaxy.managers.history_graph import HistoryGraphBuilder
-
         history, _ = self._create_history()
         in_hda = self._create_hda(history, name="input")
 
@@ -1059,8 +1044,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         subset of the unseeded result (proving it's a pure post-filter,
         not a different construction path).
         """
-        from sqlalchemy import event
-
         history, _ = self._create_history()
         # Build a small chain so there's something to filter.
         chain = self._build_linear_chain(history, length=3)
@@ -1177,10 +1160,10 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
 
 # ── Scalability / Boundedness Tests ──
 
-GRAPH_SCALE_HISTORY_SIZE = int(os.environ.get("GRAPH_SCALE_HISTORY_SIZE", 500))
-GRAPH_SCALE_CHAIN_LENGTH = int(os.environ.get("GRAPH_SCALE_CHAIN_LENGTH", 100))
-GRAPH_SCALE_COLLECTION_COUNT = int(os.environ.get("GRAPH_SCALE_COLLECTION_COUNT", 10))
-GRAPH_SCALE_COLLECTION_SIZE = int(os.environ.get("GRAPH_SCALE_COLLECTION_SIZE", 50))
+GRAPH_SCALE_HISTORY_SIZE = int(os.environ.get("GRAPH_SCALE_HISTORY_SIZE", 250))
+GRAPH_SCALE_CHAIN_LENGTH = int(os.environ.get("GRAPH_SCALE_CHAIN_LENGTH", 60))
+GRAPH_SCALE_COLLECTION_COUNT = int(os.environ.get("GRAPH_SCALE_COLLECTION_COUNT", 5))
+GRAPH_SCALE_COLLECTION_SIZE = int(os.environ.get("GRAPH_SCALE_COLLECTION_SIZE", 20))
 
 
 class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):

From 0834a34bed9996b856a0b30bf63f265a9439aaad Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Sat, 2 May 2026 09:37:59 +0300
Subject: [PATCH 26/28] Fix expected error code in test

---
 lib/galaxy_test/api/test_histories.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/galaxy_test/api/test_histories.py b/lib/galaxy_test/api/test_histories.py
index 53bfc672638..d17f14ddf98 100644
--- a/lib/galaxy_test/api/test_histories.py
+++ b/lib/galaxy_test/api/test_histories.py
@@ -1334,4 +1334,4 @@ class TestHistoryGraphApi(ApiTestCase, BaseHistories):
 
     def test_nonexistent_history_is_rejected(self):
         response = self.dataset_populator.get_history_graph_raw("0000000000000000")
-        self._assert_status_code_is(response, 404)
+        self._assert_status_code_is(response, 400)

From 6e23e9d3e4f9b718cae36943a4f067c3949c2870 Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Sat, 2 May 2026 13:57:53 +0300
Subject: [PATCH 27/28] Add shim to ensure that manager itself is not
 reinstantiated, align with existing manager pattern

---
 lib/galaxy/managers/history_graph.py          | 30 +++++++++++++++++++
 .../webapps/galaxy/services/histories.py      |  9 +++---
 .../app/managers/test_HistoryGraphBuilder.py  | 22 ++++++--------
 3 files changed, 43 insertions(+), 18 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index 5e1e5766e3f..a1aefda13ce 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -44,6 +44,7 @@ from galaxy.schema.history_graph import (
     TruncationInfo,
 )
 from galaxy.security.idencoding import IdEncodingHelper
+from galaxy.structured_app import MinimalManagerApp
 from galaxy.tool_util.toolbox import AbstractToolBox
 
 log = logging.getLogger(__name__)
@@ -54,6 +55,35 @@ NODE_TYPE_PREFIX = {"dataset": "d", "collection": "c", "tool_request": "r"}
 MAX_LIMIT = 1000
 
 
+class HistoryGraphManager:
+    def __init__(self, app: MinimalManagerApp):
+        self.app = app
+
+    def build(
+        self,
+        sa_session: Session,
+        history_id: int,
+        limit: int = 500,
+        include_deleted: bool = False,
+        seed: Optional[str] = None,
+        direction: Literal["backward", "forward", "both"] = "both",
+        depth: int = 5,
+        seed_scope_hid: Optional[int] = None,
+    ) -> HistoryGraphResponse:
+        return HistoryGraphBuilder(
+            sa_session=sa_session,
+            security=self.app.security,
+            toolbox=self.app.toolbox,
+            history_id=history_id,
+            limit=limit,
+            include_deleted=include_deleted,
+            seed=seed,
+            direction=direction,
+            depth=depth,
+            seed_scope_hid=seed_scope_hid,
+        ).build()
+
+
 class HistoryGraphBuilder:
     """Builds a provenance graph from selected history items.
 
diff --git a/lib/galaxy/webapps/galaxy/services/histories.py b/lib/galaxy/webapps/galaxy/services/histories.py
index fd18c61b7db..e5f06fd8dae 100644
--- a/lib/galaxy/webapps/galaxy/services/histories.py
+++ b/lib/galaxy/webapps/galaxy/services/histories.py
@@ -40,7 +40,7 @@ from galaxy.managers.histories import (
     HistoryManager,
     HistorySerializer,
 )
-from galaxy.managers.history_graph import HistoryGraphBuilder
+from galaxy.managers.history_graph import HistoryGraphManager
 from galaxy.managers.users import UserManager
 from galaxy.model import (
     HistoryDatasetAssociation,
@@ -131,6 +131,7 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
         deserializer: HistoryDeserializer,
         citations_manager: CitationsManager,
         history_export_manager: HistoryExportManager,
+        history_graph_manager: HistoryGraphManager,
         filters: HistoryFilters,
         short_term_storage_allocator: ShortTermStorageAllocator,
         notification_service: NotificationService,
@@ -142,6 +143,7 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
         self.deserializer = deserializer
         self.citations_manager = citations_manager
         self.history_export_manager = history_export_manager
+        self.history_graph_manager = history_graph_manager
         self.filters = filters
         self.shareable_service = ShareableHistoryService(self.manager, self.serializer, notification_service)
         self.short_term_storage_allocator = short_term_storage_allocator
@@ -397,19 +399,16 @@ class HistoriesService(ServiceBase, ConsumesModelStores, ServesExportStores):
     ) -> HistoryGraphResponse:
         history = self.manager.get_accessible(history_id, trans.user, current_history=trans.history)
         seed_scope_hid = self._resolve_seed_scope_hid(trans, history.id, seed_scope) if seed_scope else None
-        builder = HistoryGraphBuilder(
+        return self.history_graph_manager.build(
             sa_session=trans.sa_session,
-            security=self.security,
             history_id=history.id,
             limit=limit,
-            toolbox=trans.app.toolbox,
             include_deleted=include_deleted,
             seed=seed,
             direction=direction,
             depth=depth,
             seed_scope_hid=seed_scope_hid,
         )
-        return builder.build()
 
     def _resolve_seed_scope_hid(self, trans: ProvidesHistoryContext, history_id: int, seed_scope: str) -> int:
         db_id = self.security.decode_id(seed_scope[1:])
diff --git a/test/unit/app/managers/test_HistoryGraphBuilder.py b/test/unit/app/managers/test_HistoryGraphBuilder.py
index c6d3b6fffc0..a2746cc15b3 100644
--- a/test/unit/app/managers/test_HistoryGraphBuilder.py
+++ b/test/unit/app/managers/test_HistoryGraphBuilder.py
@@ -10,7 +10,7 @@ from galaxy.managers.collections import DatasetCollectionManager
 from galaxy.managers.datasets import DatasetManager
 from galaxy.managers.hdas import HDAManager
 from galaxy.managers.histories import HistoryManager
-from galaxy.managers.history_graph import HistoryGraphBuilder
+from galaxy.managers.history_graph import HistoryGraphManager
 from .base import (
     BaseTestCase,
     CreatesCollectionsMixin,
@@ -35,6 +35,8 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         self.hda_manager = self.app[HDAManager]
         self.history_manager = self.app[HistoryManager]
         self.collection_manager = self.app[DatasetCollectionManager]
+        self.app._toolbox = None  # type: ignore[assignment]
+        self.history_graph_manager = self.app[HistoryGraphManager]
 
     def _build_graph(
         self,
@@ -45,9 +47,8 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         limit=500,
         seed_scope_hid=None,
     ):
-        builder = HistoryGraphBuilder(
+        return self.history_graph_manager.build(
             sa_session=self.trans.sa_session,
-            security=self.app.security,
             history_id=history.id,
             limit=limit,
             seed=seed,
@@ -55,7 +56,6 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
             depth=depth,
             seed_scope_hid=seed_scope_hid,
         )
-        return builder.build()
 
     def _encode(self, prefix, db_id):
         return f"{prefix}{self.app.security.encode_id(db_id)}"
@@ -580,13 +580,11 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         assert len(graph.nodes) == 0
 
         # With include_deleted: included
-        builder = HistoryGraphBuilder(
+        graph = self.history_graph_manager.build(
             sa_session=self.trans.sa_session,
-            security=self.app.security,
             history_id=history.id,
             include_deleted=True,
         )
-        graph = builder.build()
         assert len(graph.nodes) == 1
 
     def test_expanding_limit_generally_additive(self):
@@ -1015,13 +1013,11 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         hdca.implicit_collection_jobs_id = icj.id  # implicit branch
         self.trans.sa_session.flush()
 
-        builder = HistoryGraphBuilder(
+        graph = self.history_graph_manager.build(
             sa_session=self.trans.sa_session,
-            security=self.app.security,
             history_id=history.id,
             limit=500,
         )
-        graph = builder.build()
 
         hdca_enc = self._encode("c", hdca.id)
         node_ids = {n.id for n in graph.nodes}
@@ -1181,15 +1177,15 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
         self.hda_manager = self.app[HDAManager]
         self.history_manager = self.app[HistoryManager]
         self.collection_manager = self.app[DatasetCollectionManager]
+        self.app._toolbox = None  # type: ignore[assignment]
+        self.history_graph_manager = self.app[HistoryGraphManager]
 
     def _build_graph(self, history, **kwargs):
-        builder = HistoryGraphBuilder(
+        return self.history_graph_manager.build(
             sa_session=self.trans.sa_session,
-            security=self.app.security,
             history_id=history.id,
             **kwargs,
         )
-        return builder.build()
 
     def _encode(self, prefix, db_id):
         return f"{prefix}{self.app.security.encode_id(db_id)}"

From 606aa19635f6c4b44dbca7c51b9867899ce5543d Mon Sep 17 00:00:00 2001
From: guerler <aysam.guerler@gmail.com>
Date: Sat, 2 May 2026 14:06:12 +0300
Subject: [PATCH 28/28] Use DataItemSourceType, fix linting

---
 lib/galaxy/managers/history_graph.py               | 5 +++--
 test/unit/app/managers/test_HistoryGraphBuilder.py | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/galaxy/managers/history_graph.py b/lib/galaxy/managers/history_graph.py
index a1aefda13ce..0ad6eeb674f 100644
--- a/lib/galaxy/managers/history_graph.py
+++ b/lib/galaxy/managers/history_graph.py
@@ -43,6 +43,7 @@ from galaxy.schema.history_graph import (
     HistoryGraphResponse,
     TruncationInfo,
 )
+from galaxy.schema.schema import DataItemSourceType
 from galaxy.security.idencoding import IdEncodingHelper
 from galaxy.structured_app import MinimalManagerApp
 from galaxy.tool_util.toolbox import AbstractToolBox
@@ -413,9 +414,9 @@ class HistoryGraphBuilder:
                     parent = parent[step]
                 if isinstance(parent, dict):
                     src = parent.get("src")
-                    if src == "hda":
+                    if src == DataItemSourceType.hda:
                         refs.add(("dataset", value))
-                    elif src == "hdca":
+                    elif src == DataItemSourceType.hdca:
                         refs.add(("collection", value))
             return key, value
 
diff --git a/test/unit/app/managers/test_HistoryGraphBuilder.py b/test/unit/app/managers/test_HistoryGraphBuilder.py
index a2746cc15b3..dc99a266153 100644
--- a/test/unit/app/managers/test_HistoryGraphBuilder.py
+++ b/test/unit/app/managers/test_HistoryGraphBuilder.py
@@ -35,7 +35,7 @@ class TestHistoryGraphBuilder(BaseTestCase, CreatesCollectionsMixin):
         self.hda_manager = self.app[HDAManager]
         self.history_manager = self.app[HistoryManager]
         self.collection_manager = self.app[DatasetCollectionManager]
-        self.app._toolbox = None  # type: ignore[assignment]
+        self.app._toolbox = None
         self.history_graph_manager = self.app[HistoryGraphManager]
 
     def _build_graph(
@@ -1177,7 +1177,7 @@ class TestHistoryGraphBuilderBoundedness(BaseTestCase, CreatesCollectionsMixin):
         self.hda_manager = self.app[HDAManager]
         self.history_manager = self.app[HistoryManager]
         self.collection_manager = self.app[DatasetCollectionManager]
-        self.app._toolbox = None  # type: ignore[assignment]
+        self.app._toolbox = None
         self.history_graph_manager = self.app[HistoryGraphManager]
 
     def _build_graph(self, history, **kwargs):