From 44e7e634eb7c92b2187ca90975c67fa464183e19 Mon Sep 17 00:00:00 2001
From: ernest micklei <ernest.micklei@gmail.com>
Date: Thu, 25 Sep 2025 12:49:54 +0200
Subject: [PATCH 01/11] initial

---
 service.go | 37 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/service.go b/service.go
index 07b0852..7fe0011 100644
--- a/service.go
+++ b/service.go
@@ -44,6 +44,7 @@ func (s *service) init() {
 type service struct {
 	explorer      *explorer
 	indexTemplate *template.Template
+	httpServer    *http.Server
 }
 
 // NewService creates a new to explore one or more values (structures).
@@ -53,6 +54,36 @@ func NewService(labelValuePairs ...any) Service {
 	return s
 }
 
+// Break will listen and serve on the given http port and path.
+// it accepts 0 or 1 Options to override defaults.
+// The explorer page will have a button "Resume" that stops the server
+// and unblocks the go-routine that started it.
+func (s *service) Break(opts ...Options) {
+	if len(opts) > 0 {
+		s.explorer.options = &opts[0]
+	}
+	port := s.explorer.options.httpPort()
+	serveMux := s.explorer.options.serveMux()
+	rootPath := s.explorer.options.rootPath()
+	serveMux.Handle(rootPath, s)
+	server := &http.Server{
+		Addr:    fmt.Sprintf(":%d", port),
+		Handler: serveMux,
+	}
+	s.httpServer = server
+	if err := server.ListenAndServe(); err != nil {
+		slog.Error("[structexplorer] failed to start service", "err", err)
+	}
+}
+
+func (s *service) resume() {
+	if s.httpServer == nil {
+		return
+	}
+	s.httpServer.Close()
+	s.httpServer = nil
+}
+
 // Start will listen and serve on the given http port and path.
 // it accepts 0 or 1 Options to override defaults.
 func (s *service) Start(opts ...Options) {
@@ -64,7 +95,7 @@ func (s *service) Start(opts ...Options) {
 	rootPath := s.explorer.options.rootPath()
 	slog.Info(fmt.Sprintf("starting go struct explorer at http://localhost:%d%s on %v", port, rootPath, s.explorer.rootKeys()))
 	serveMux.Handle(rootPath, s)
-	if err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil); err != nil {
+	if err := http.ListenAndServe(fmt.Sprintf(":%d", port), serveMux); err != nil {
 		slog.Error("[structexplorer] failed to start service", "err", err)
 	}
 }
@@ -204,6 +235,10 @@ func (s *service) serveInstructions(w http.ResponseWriter, r *http.Request) {
 	case "clear":
 		s.explorer.removeNonRootObjects()
 		return
+	case "resume":
+		s.resume()
+		return
+
 	default:
 		slog.Warn("[structexplorer] invalid direction", "action", cmd.Action)
 		http.Error(w, "invalid action", http.StatusBadRequest)

From 8162b3ae92c020f03e5ecee89ac9a06e06305218 Mon Sep 17 00:00:00 2001
From: ernest micklei <ernest.micklei@gmail.com>
Date: Thu, 25 Sep 2025 14:44:41 +0200
Subject: [PATCH 02/11] add example break

---
 examples/break/main_test.go | 18 ++++++++++++++++++
 index_tmpl.html             |  3 +++
 open.go                     | 21 +++++++++++++++++++++
 script.js                   | 14 ++++++++++++--
 service.go                  | 12 ++++++++----
 5 files changed, 62 insertions(+), 6 deletions(-)
 create mode 100644 examples/break/main_test.go
 create mode 100644 open.go

diff --git a/examples/break/main_test.go b/examples/break/main_test.go
new file mode 100644
index 0000000..4665051
--- /dev/null
+++ b/examples/break/main_test.go
@@ -0,0 +1,18 @@
+package main
+
+import (
+	"log"
+	"testing"
+
+	"github.com/emicklei/structexplorer"
+)
+
+func TestWithBreak(t *testing.T) {
+	target := struct{ Field string }{Field: "hello"}
+
+	log.Println("before opening the explorer to see state")
+
+	structexplorer.NewService("debugging", target).Break()
+
+	log.Println("after opening the explorer to see state")
+}
diff --git a/index_tmpl.html b/index_tmpl.html
index 0503364..c5f85af 100644
--- a/index_tmpl.html
+++ b/index_tmpl.html
@@ -121,6 +121,9 @@
             <span id="theme-toggle" class="theme-toggle" title="Toggle Theme"
                 >🔄</span
             >
+            <button class="btn" title="resume from a break" onclick="javascript:resume();">
+                resume
+            </button>        
         </p>
 
         <script>
diff --git a/open.go b/open.go
new file mode 100644
index 0000000..46cd064
--- /dev/null
+++ b/open.go
@@ -0,0 +1,21 @@
+package structexplorer
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+)
+
+// Open calls the OS default program for uri
+func open(uri string) error {
+	switch {
+	case "windows" == runtime.GOOS:
+		return exec.Command("rundll32", "url.dll,FileProtocolHandler", uri).Start()
+	case "darwin" == runtime.GOOS:
+		return exec.Command("open", uri).Start()
+	case "linux" == runtime.GOOS:
+		return exec.Command("xdg-open", uri).Start()
+	default:
+		return fmt.Errorf("unable to open uri:%v on:%v", uri, runtime.GOOS)
+	}
+}
diff --git a/script.js b/script.js
index 6b5a737..9a18359 100644
--- a/script.js
+++ b/script.js
@@ -13,8 +13,18 @@ function explore(row, column, selectNode, action) {
         action: action,
         selections: getSelectValues(selectNode)
     }));
-    xhr.onload = function () { window.location.reload(); }
+    xhr.onload = function() { window.location.reload(); }
 }
+
+function resume() {
+    const xhr = new XMLHttpRequest();
+    xhr.open("POST", window.location.href);
+    xhr.setRequestHeader("Content-Type", "application/json; charset=UTF-8")
+    xhr.send(JSON.stringify({
+        action: "resume" 
+    }));
+}
+
 // Return an array of the selected option values in the control.
 // Select is an HTML select element.
 function getSelectValues(select) {
@@ -34,4 +44,4 @@ function getSelectValues(select) {
         result.push(opt.value || opt.text);
     }
     return result;
-}
\ No newline at end of file
+} 
\ No newline at end of file
diff --git a/service.go b/service.go
index 7fe0011..65ed414 100644
--- a/service.go
+++ b/service.go
@@ -1,6 +1,7 @@
 package structexplorer
 
 import (
+	"context"
 	_ "embed"
 	"encoding/json"
 	"fmt"
@@ -18,6 +19,9 @@ type Service interface {
 	// Start accepts 0 or 1 Options
 	Start(opts ...Options)
 
+	// Break accepts 0 or 1 Options
+	Break(opts ...Options)
+
 	// Dump writes an HTML file for displaying the current state of the explorer and its entries.
 	Dump()
 
@@ -71,16 +75,16 @@ func (s *service) Break(opts ...Options) {
 		Handler: serveMux,
 	}
 	s.httpServer = server
-	if err := server.ListenAndServe(); err != nil {
-		slog.Error("[structexplorer] failed to start service", "err", err)
-	}
+	open(fmt.Sprintf("http://localhost:%d", port))
+	// this blocks until server is closed by resume operation.
+	server.ListenAndServe()
 }
 
 func (s *service) resume() {
 	if s.httpServer == nil {
 		return
 	}
-	s.httpServer.Close()
+	s.httpServer.Shutdown(context.Background())
 	s.httpServer = nil
 }
 

From e0bfd1eeb57e8cb012f490cbff8af72f8ac5da39 Mon Sep 17 00:00:00 2001
From: ernest micklei <ernest.micklei@gmail.com>
Date: Thu, 25 Sep 2025 15:32:31 +0200
Subject: [PATCH 03/11] enable resume when breaking

---
 explorer.go      | 3 +++
 index_builder.go | 9 +++++----
 index_data.go    | 7 ++++---
 index_tmpl.html  | 2 ++
 service.go       | 6 +++++-
 5 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/explorer.go b/explorer.go
index 14010c6..fd6dd6a 100644
--- a/explorer.go
+++ b/explorer.go
@@ -164,6 +164,9 @@ func (e *explorer) putObjectStartingAt(row, col int, access objectAccess, option
 }
 
 func (e *explorer) buildIndexData(b *indexDataBuilder) indexData {
+	// was it starting using Break?
+	b.data.IsBreaking = b.isBreaking
+
 	for row, each := range e.accessMap {
 		for col, access := range each {
 			info := b.build(row, col, access)
diff --git a/index_builder.go b/index_builder.go
index c622227..d90f452 100644
--- a/index_builder.go
+++ b/index_builder.go
@@ -10,10 +10,11 @@ import (
 )
 
 type indexDataBuilder struct {
-	data     indexData
-	seq      int
-	notLive  bool
-	selectID string // id of the added fieldList (select element)
+	data       indexData
+	seq        int
+	notLive    bool
+	isBreaking bool   // service is started with Break(...)
+	selectID   string // id of the added fieldList (select element)
 }
 
 func newIndexDataBuilder() *indexDataBuilder {
diff --git a/index_data.go b/index_data.go
index 70d1b0f..ae4cb15 100644
--- a/index_data.go
+++ b/index_data.go
@@ -14,9 +14,10 @@ var styleCSS string
 
 type (
 	indexData struct {
-		Rows   []tableRow
-		Script template.JS
-		Style  template.CSS
+		Rows       []tableRow
+		Script     template.JS
+		Style      template.CSS
+		IsBreaking bool
 	}
 	tableRow struct {
 		Cells []fieldList
diff --git a/index_tmpl.html b/index_tmpl.html
index c5f85af..562fa9b 100644
--- a/index_tmpl.html
+++ b/index_tmpl.html
@@ -121,9 +121,11 @@
             <span id="theme-toggle" class="theme-toggle" title="Toggle Theme"
                 >🔄</span
             >
+            {{- if .IsBreaking }}
             <button class="btn" title="resume from a break" onclick="javascript:resume();">
                 resume
             </button>        
+            {{- end }}
         </p>
 
         <script>
diff --git a/service.go b/service.go
index 65ed414..3901374 100644
--- a/service.go
+++ b/service.go
@@ -133,7 +133,11 @@ func (s *service) serveIndex(w http.ResponseWriter, _ *http.Request) {
 	defer s.protect()()
 
 	w.Header().Set("content-type", "text/html")
-	if err := s.indexTemplate.Execute(w, s.explorer.buildIndexData(newIndexDataBuilder())); err != nil {
+
+	builder := newIndexDataBuilder()
+	builder.isBreaking = s.httpServer != nil
+
+	if err := s.indexTemplate.Execute(w, s.explorer.buildIndexData(builder)); err != nil {
 		slog.Error("failed to execute template", "err", err)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return

From 41ebadc34863c04bbf773a321c00c0ad9847ed51 Mon Sep 17 00:00:00 2001
From: ernest micklei <ernest.micklei@gmail.com>
Date: Fri, 26 Sep 2025 09:00:05 +0200
Subject: [PATCH 04/11] add Break func

---
 service.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/service.go b/service.go
index 3901374..1179924 100644
--- a/service.go
+++ b/service.go
@@ -58,9 +58,16 @@ func NewService(labelValuePairs ...any) Service {
 	return s
 }
 
+// Break will listen and serve on the default endpoint and open a window.
+// The explorer page will have a button "Resume" that stops the server
+// and unblocks the go-routine that started it.
+func Break(keyvaluePairs ...any) {
+	NewService(keyvaluePairs...).Break()
+}
+
 // Break will listen and serve on the given http port and path.
 // it accepts 0 or 1 Options to override defaults.
-// The explorer page will have a button "Resume" that stops the server
+// The opened explorer page will have a button "Resume" that stops the server
 // and unblocks the go-routine that started it.
 func (s *service) Break(opts ...Options) {
 	if len(opts) > 0 {

From 29b402b26e2834fe121400129610baa7d44f434a Mon Sep 17 00:00:00 2001
From: ernest micklei <ernest.micklei@gmail.com>
Date: Fri, 26 Sep 2025 10:11:04 +0200
Subject: [PATCH 05/11] update readme

---
 README.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/README.md b/README.md
index 77b5463..39875b9 100644
--- a/README.md
+++ b/README.md
@@ -49,6 +49,14 @@ Note: if the list contains just one structural value then selecting it can be sk
 
 ## explore while debugging
 
+### Break
+
+The following instruction will start the explorer on a struct, opens a Browser and provides a `resume` button to stop the explorer and resume the Go-routine that started it.
+
+    structexplorer.Break("myStruct", myStruct)
+
+### Dump
+
 Currently, the standard Go debugger `delve` stops all goroutines while in a debugging session.
 This means that if you have started the `structexplorer` service in your program, it will not respond to any HTTP requests during that session.
 

From 20df9437c72bfc61b4d4182523f947d3c7fd4137 Mon Sep 17 00:00:00 2001
From: ernest micklei <ernest.micklei@gmail.com>
Date: Mon, 29 Sep 2025 09:54:29 +0200
Subject: [PATCH 06/11] update changes, example, doc

---
 CHANGES.md                  |  4 ++++
 README.md                   |  3 +++
 examples/break/main.go      | 20 ++++++++++++++++++++
 examples/break/main_test.go |  2 +-
 service.go                  |  2 +-
 5 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 examples/break/main.go

diff --git a/CHANGES.md b/CHANGES.md
index 045438c..031b404 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,3 +1,7 @@
+### v0.9.0
+
+ - adds Break(key,value,...) for temporary runtime inspection. 
+
 ### v0.8.1
 
  - Explore replaces object with same root label.
diff --git a/README.md b/README.md
index 39875b9..4a19377 100644
--- a/README.md
+++ b/README.md
@@ -72,3 +72,6 @@ Another method is to use a special test case which starts an explorer at the end
 ## examples
 
 See folder `examples` for simple programs demonstrating each feature.
+
+
+&copy; 2025. https://ernestmicklei.com. MIT License
\ No newline at end of file
diff --git a/examples/break/main.go b/examples/break/main.go
new file mode 100644
index 0000000..8c280c2
--- /dev/null
+++ b/examples/break/main.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+	"log"
+
+	"github.com/emicklei/structexplorer"
+)
+
+// go run .
+func main() {
+	greeting := map[string]any{}
+	hello := struct{ Field string }{Field: "hello"}
+	greeting["hi"] = hello
+
+	log.Println("before opening the explorer to see state")
+
+	structexplorer.Break("map", greeting)
+
+	log.Println("after opening the explorer to see state")
+}
diff --git a/examples/break/main_test.go b/examples/break/main_test.go
index 4665051..7fd1ce4 100644
--- a/examples/break/main_test.go
+++ b/examples/break/main_test.go
@@ -12,7 +12,7 @@ func TestWithBreak(t *testing.T) {
 
 	log.Println("before opening the explorer to see state")
 
-	structexplorer.NewService("debugging", target).Break()
+	structexplorer.Break("debugging", target)
 
 	log.Println("after opening the explorer to see state")
 }
diff --git a/service.go b/service.go
index 1179924..6d44d93 100644
--- a/service.go
+++ b/service.go
@@ -58,7 +58,7 @@ func NewService(labelValuePairs ...any) Service {
 	return s
 }
 
-// Break will listen and serve on the default endpoint and open a window.
+// Break will listen and serve on the default endpoint and opens a window.
 // The explorer page will have a button "Resume" that stops the server
 // and unblocks the go-routine that started it.
 func Break(keyvaluePairs ...any) {

From 2bbf0d3c10d3d3f4f3870ccefdf990db46fd4586 Mon Sep 17 00:00:00 2001
From: Nil Zork <ernest.micklei@gmail.com>
Date: Thu, 2 Oct 2025 22:19:43 +0200
Subject: [PATCH 07/11] do not use default serve-mux in break

---
 service.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/service.go b/service.go
index 6d44d93..028b48b 100644
--- a/service.go
+++ b/service.go
@@ -62,7 +62,9 @@ func NewService(labelValuePairs ...any) Service {
 // The explorer page will have a button "Resume" that stops the server
 // and unblocks the go-routine that started it.
 func Break(keyvaluePairs ...any) {
-	NewService(keyvaluePairs...).Break()
+	NewService(keyvaluePairs...).Break(Options{
+		ServeMux: new(http.ServeMux),
+	})
 }
 
 // Break will listen and serve on the given http port and path.

From da0524e7dd886b7bdc816577e073ddfa25038700 Mon Sep 17 00:00:00 2001
From: Nil Zork <ernest.micklei@gmail.com>
Date: Sat, 4 Oct 2025 13:31:44 +0200
Subject: [PATCH 08/11] add Dump option

---
 CHANGES.md |  1 +
 service.go | 10 +++++++---
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 031b404..a992e00 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,7 @@
 ### v0.9.0
 
  - adds Break(key,value,...) for temporary runtime inspection. 
+ - add optional filename to Dump()
 
 ### v0.8.1
 
diff --git a/service.go b/service.go
index 028b48b..243b10e 100644
--- a/service.go
+++ b/service.go
@@ -23,7 +23,7 @@ type Service interface {
 	Break(opts ...Options)
 
 	// Dump writes an HTML file for displaying the current state of the explorer and its entries.
-	Dump()
+	Dump(optionFilename ...string)
 
 	// Explore adds or replaces (matching on label) a new entry for a value unless it cannot be explored.
 	// The object will be placed on the next available column on row 1.
@@ -190,10 +190,14 @@ func (s *service) Explore(label string, value any, options ...ExploreOption) Ser
 }
 
 // Dump writes an HTML file for displaying the current state of the explorer and its entries.
-func (s *service) Dump() {
+func (s *service) Dump(optionalFilename ...string) {
 	defer s.protect()()
 
-	out, err := os.Create("structexplorer.html")
+	fName := "structexplorer.html"
+	if len(optionalFilename) > 0 && optionalFilename[0] != "" {
+		fName = optionalFilename[0]
+	}
+	out, err := os.Create(fName)
 	if err != nil {
 		slog.Error("failed to create dump file", "err", err)
 	}

From cc658ae6cc9889ca560a2bfddefe9931c49a1939 Mon Sep 17 00:00:00 2001
From: Nil Zork <ernest.micklei@gmail.com>
Date: Sat, 4 Oct 2025 13:34:48 +0200
Subject: [PATCH 09/11] update doc and button label

---
 README.md       | 3 ++-
 index_tmpl.html | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 4a19377..3804b4f 100644
--- a/README.md
+++ b/README.md
@@ -65,7 +65,8 @@ The explorer can also be asked to dump an HTML page with the current state of va
     s := structexplorer.NewService()
     s.Explore("yours", yourStruct)
     s.ExplorePath("yours.field") // dotted path of fields starting with an explore label
-    s.Dump()
+    s.Dump() 
+    // or s.Dump("yourfile.html")
 
 Another method is to use a special test case which starts an explorer at the end of a test and then run it with a longer acceptable timeout.
 
diff --git a/index_tmpl.html b/index_tmpl.html
index 562fa9b..beaa2c7 100644
--- a/index_tmpl.html
+++ b/index_tmpl.html
@@ -123,7 +123,7 @@
             >
             {{- if .IsBreaking }}
             <button class="btn" title="resume from a break" onclick="javascript:resume();">
-                resume
+                Resume from Breakpoint
             </button>        
             {{- end }}
         </p>

From cb2140f21add44732a24ba39c7efda337ecdb071 Mon Sep 17 00:00:00 2001
From: Nil Zork <ernest.micklei@gmail.com>
Date: Sat, 4 Oct 2025 16:16:29 +0200
Subject: [PATCH 10/11] fix next free

---
 explore_options.go |  4 ++--
 explorer.go        | 12 +++++++++---
 explorer_test.go   | 23 ++++++++++++++++++++++-
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/explore_options.go b/explore_options.go
index 37ff392..9fe30df 100644
--- a/explore_options.go
+++ b/explore_options.go
@@ -20,7 +20,7 @@ func RowColumn(row, column int) ExploreOption {
 func Column(column int) ExploreOption {
 	return ExploreOption{
 		placement: func(e *explorer) (newRow, newColumn int) {
-			return e.nextFreeRow(column) + 1, column
+			return e.nextFreeRow(column), column
 		},
 	}
 }
@@ -29,7 +29,7 @@ func Column(column int) ExploreOption {
 func Row(row int) ExploreOption {
 	return ExploreOption{
 		placement: func(e *explorer) (newRow, newColumn int) {
-			return row, e.nextFreeColumn(row) + 1
+			return row, e.nextFreeColumn(row)
 		},
 	}
 }
diff --git a/explorer.go b/explorer.go
index fd6dd6a..cee7a11 100644
--- a/explorer.go
+++ b/explorer.go
@@ -32,17 +32,17 @@ type explorer struct {
 }
 
 func (e *explorer) nextFreeColumn(row int) int {
-	max := 0
 	cols, ok := e.accessMap[row]
 	if !ok {
 		return 0
 	}
+	max := -1
 	for col := range cols {
 		if col > max {
 			max = col
 		}
 	}
-	return max
+	return max + 1
 }
 
 func (e *explorer) nextFreeRow(column int) int {
@@ -54,7 +54,13 @@ func (e *explorer) nextFreeRow(column int) int {
 			return row
 		}
 	}
-	return 0
+	max := -1
+	for row := range e.accessMap {
+		if row > max {
+			max = row
+		}
+	}
+	return max + 1
 }
 
 func (e *explorer) rootKeys() (list []string) {
diff --git a/explorer_test.go b/explorer_test.go
index d189e76..74d0454 100644
--- a/explorer_test.go
+++ b/explorer_test.go
@@ -5,6 +5,27 @@ import (
 	"time"
 )
 
+func TestExplorerFreeColumn(t *testing.T) {
+	x := newExplorerOnAll()
+	r := x.nextFreeRow(0)
+	if got, want := r, 0; got != want {
+		t.Errorf("got [%[1]v:%[1]T] want [%[2]v:%[2]T]", got, want)
+	}
+	c := x.nextFreeColumn(0)
+	if got, want := c, 0; got != want {
+		t.Errorf("got [%[1]v:%[1]T] want [%[2]v:%[2]T]", got, want)
+	}
+	x.putObjectStartingAt(1, 1, objectAccess{}, Row(0))
+	r = x.nextFreeRow(0)
+	if got, want := r, 1; got != want {
+		t.Errorf("got [%[1]v:%[1]T] want [%[2]v:%[2]T]", got, want)
+	}
+	c = x.nextFreeColumn(1)
+	if got, want := c, 2; got != want {
+		t.Errorf("got [%[1]v:%[1]T] want [%[2]v:%[2]T]", got, want)
+	}
+}
+
 func TestExplorer(t *testing.T) {
 	x := newExplorerOnAll("indexData", indexData{})
 	d := x.buildIndexData(newIndexDataBuilder())
@@ -57,7 +78,7 @@ func TestExplorerTable(t *testing.T) {
 	if o2.object != o3.object {
 		t.Fail()
 	}
-	if got, want := x.nextFreeColumn(1), 1; got != want {
+	if got, want := x.nextFreeColumn(1), 2; got != want {
 		t.Errorf("got [%v]:%T want [%v]:%T", got, got, want, want)
 	}
 	if !x.canRemoveObjectAt(1, 1) {

From c1b36c71bd8b6b92f250c0fba2c0a7484186f66b Mon Sep 17 00:00:00 2001
From: Nil Zork <ernest.micklei@gmail.com>
Date: Sat, 4 Oct 2025 16:33:21 +0200
Subject: [PATCH 11/11] extend example

---
 examples/break/main_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/examples/break/main_test.go b/examples/break/main_test.go
index 7fd1ce4..7a93611 100644
--- a/examples/break/main_test.go
+++ b/examples/break/main_test.go
@@ -15,4 +15,8 @@ func TestWithBreak(t *testing.T) {
 	structexplorer.Break("debugging", target)
 
 	log.Println("after opening the explorer to see state")
+
+	target.Field = "world"
+
+	structexplorer.Break("debugging", target)
 }