@blinklabs/dingo 0.23.0 → 0.24.0

package/README.md

@@ -527,7 +527,7 @@ especially as there is functionality which has not yet been developed.
 
 ## Development / Building
 
-This requires Go 1.24 or later. You also need `make`.
+This requires Go 1.25 or later. You also need `make`.
 
 ```bash
 # Format, test, and build (default target)

package/RELEASE_NOTES.md

@@ -1,5 +1,72 @@
 # Release Notes
 
+
+## v0.23.1 (March 11, 2026)
+
+**Title:** Clearer release notes and rock-solid Docker publishing
+
+**Date:** March 11, 2026
+
+**Version:** v0.23.1
+
+Hi folks! Here’s what we shipped in v0.23.1.
+
+### ✨ What's New
+
+- **Release notes:** Release notes are easier to scan because `RELEASE_NOTES.md` now includes a complete set of notes for v0.23.0.
+
+### 💪 Improvements
+
+- **Docker publishing (Antithesis image):** Publishing is more consistent because the build pipeline now builds, tags, pushes, and generates an attestation for a Linux amd64-only Antithesis Docker image variant.
+
+### 🔧 Fixes
+
+- **No fixes:** No user-facing fixes shipped in this patch.
+
+### 📋 What You Need to Know
+
+- **Upgrade:** You’re all set—no required configuration changes for this release.
+
+### 🙏 Thank You
+
+Thank you for trying!
+
+---
+
+## v0.23.0 (March 10, 2026)
+
+**Title:** Overlay-aware validation and a smoother dev mode
+
+**Date:** March 10, 2026
+
+**Version:** v0.23.0
+
+Hi folks! Here’s what we shipped in v0.23.0.
+
+### ✨ What's New
+
+- **Transaction validation:** Transaction validation is more accurate because ledger and mempool checks now account for pending, in-flight changes with a temporary UTxO overlay.
+
+### 💪 Improvements
+
+- **Docs:** Setup is easier because `README.md` now includes expanded usage, deployment, and DevNet guidance plus a clear “not for production” warning.
+- **Publish workflow:** Publishing is more rock-solid because the release workflow now targets Node.js `24.x` and pins key GitHub Actions versions.
+- **Release notes:** Release notes are easier to scan because `RELEASE_NOTES.md` now includes v0.22.1 and tightens up transaction validation wording.
+
+### 🔧 Fixes
+
+- **Connection cleanup:** Connection-related tests are less flaky because keepalive timeouts are deterministic and connection cleanup is safer.
+
+### 📋 What You Need to Know
+
+- **Dev mode:** If you run dev mode, Dingo will automatically switch the storage mode to API, so check logs if you expected a different mode.
+
+### 🙏 Thank You
+
+Thank you for trying!
+
+---
+
 ## v0.22.1 (March 8, 2026)
 
 **Title:** Stability updates and polish

package/benchmark_results_targeted.md

@@ -0,0 +1,63 @@
+# Dingo Targeted Performance Baseline
+
+## Latest Results
+
+### Test Environment
+- **Date**: March 10, 2026
+- **Go Version**: 1.25.8
+- **OS**: Linux
+- **Architecture**: aarch64
+- **CPU Cores**: 128
+- **Data Source**: Real immutable testdata blocks from database/immutable/testdata
+- **Scope**: Current optimization baseline for core/api ingest, block processing, and batched load paths
+
+### Benchmark Results
+
+All benchmarks run with `-benchmem` flag. Iterations are Go benchmark iteration counts; benchmark-specific throughput metrics (for example `blocks/sec`) are reported separately.
+
+| Benchmark | Iterations | Time/op | Extra Metrics | Memory/op | Allocs/op |
+|-----------|------------|---------|---------------|-----------|-----------|
+| Block Batch Processing Throughput | 3 | 592689ns | 84361 blocks/sec | 91KB | 2088 |
+| Block Processing Throughput | 3 | 214857ns | 4654 blocks/sec | 26KB | 137 |
+| Block Processing Throughput Predecoded | 3 | 60121ns | 16633 blocks/sec | 2KB | 58 |
+| Raw Block Batch Processing Throughput | 3 | 515408ns | 97011 blocks/sec | 81KB | 1938 |
+| Storage Mode Ingest Steady State/api | 3 | 375174723ns | 479.8 blocks_ingested/sec, 533.1 txs_ingested/sec | 15761KB | 186666 |
+| Storage Mode Ingest Steady State/core | 3 | 152858484ns | 1178 blocks_ingested/sec, 1308 txs_ingested/sec | 7234KB | 94403 |
+| Storage Mode Ingest/api | 3 | 362809147ns | 496.1 blocks_ingested/sec, 551.3 txs_ingested/sec | 15935KB | 193665 |
+| Storage Mode Ingest/core | 3 | 235819272ns | 763.3 blocks_ingested/sec, 848.1 txs_ingested/sec | 7514KB | 101522 |
+## Performance Changes
+
+Changes since **March 10, 2026** (initial baseline):
+
+### Summary
+- **Faster benchmarks**: 4
+  - Block Batch Processing Throughput (+32%)
+  - Block Processing Throughput Predecoded (+91%)
+  - Storage Mode Ingest Steady State/api (+8%)
+  - Storage Mode Ingest Steady State/core (+55%)
+- **Slower benchmarks**: 4
+  - Block Processing Throughput (-56%)
+  - Raw Block Batch Processing Throughput (-17%)
+  - Storage Mode Ingest/api (-18%)
+  - Storage Mode Ingest/core (-37%)
+- **New benchmarks**: 0
+- **Removed benchmarks**: 0
+
+> **Note**: These are two runs from the same session establishing the baseline.
+> Variance is expected; treat this as a single baseline snapshot, not a regression.
+
+
+## Historical Results
+
+### March 10, 2026
+
+| Benchmark | Iterations | Time/op | Extra Metrics | Memory/op | Allocs/op |
+|-----------|------------|---------|---------------|-----------|-----------|
+| Block Batch Processing Throughput | 3 | 781159ns | 64007 blocks/sec | 99KB | 2138 |
+| Block Processing Throughput | 3 | 93495ns | 10696 blocks/sec | 26KB | 138 |
+| Block Processing Throughput Predecoded | 3 | 114562ns | 8729 blocks/sec | 2KB | 60 |
+| Raw Block Batch Processing Throughput | 3 | 427847ns | 116864 blocks/sec | 81KB | 1938 |
+| Storage Mode Ingest Steady State/api | 3 | 406074114ns | 443.3 blocks_ingested/sec, 492.5 txs_ingested/sec | 15743KB | 186725 |
+| Storage Mode Ingest Steady State/core | 3 | 236358805ns | 761.6 blocks_ingested/sec, 846.2 txs_ingested/sec | 7245KB | 94503 |
+| Storage Mode Ingest/api | 3 | 298992974ns | 602.0 blocks_ingested/sec, 668.9 txs_ingested/sec | 15861KB | 193541 |
+| Storage Mode Ingest/core | 3 | 148714628ns | 1210 blocks_ingested/sec, 1345 txs_ingested/sec | 7449KB | 101364 |

package/generate_benchmarks.sh

@@ -15,11 +15,17 @@
 # limitations under the License.
 
 # Script to generate benchmark results for Dingo ledger and database with historical tracking
-# Usage: ./generate_benchmarks.sh [output_file] [--write]
+# Usage: ./generate_benchmarks.sh [output_file] [--write] [--bench regex] [--packages pkg1,pkg2] [--benchtime duration] [--title title] [--scope scope] [--data-source source]
 #   --write: Write results to file (default: display only)
 
 WRITE_TO_FILE=false
 OUTPUT_FILE="benchmark_results.md"
+BENCH_REGEX="."
+BENCH_PACKAGES="./..."
+REPORT_TITLE="Dingo Ledger & Database Benchmark Results"
+REPORT_SCOPE=""
+REPORT_DATA_SOURCE="Real Cardano preview testnet data (40k+ blocks, slots 0-863,996)"
+BENCH_TIME=""
 
 # Parse arguments
 while [[ $# -gt 0 ]]; do
@@ -28,9 +34,39 @@ while [[ $# -gt 0 ]]; do
             WRITE_TO_FILE=true
             shift
             ;;
+        --bench)
+            [[ -z "${2:-}" || "$2" == -* ]] && { echo "Error: --bench requires a value"; exit 1; }
+            BENCH_REGEX="$2"
+            shift 2
+            ;;
+        --packages)
+            [[ -z "${2:-}" || "$2" == -* ]] && { echo "Error: --packages requires a value"; exit 1; }
+            BENCH_PACKAGES="$2"
+            shift 2
+            ;;
+        --benchtime)
+            [[ -z "${2:-}" || "$2" == -* ]] && { echo "Error: --benchtime requires a value"; exit 1; }
+            BENCH_TIME="$2"
+            shift 2
+            ;;
+        --title)
+            [[ -z "${2:-}" || "$2" == -* ]] && { echo "Error: --title requires a value"; exit 1; }
+            REPORT_TITLE="$2"
+            shift 2
+            ;;
+        --scope)
+            [[ -z "${2:-}" || "$2" == -* ]] && { echo "Error: --scope requires a value"; exit 1; }
+            REPORT_SCOPE="$2"
+            shift 2
+            ;;
+        --data-source)
+            [[ -z "${2:-}" || "$2" == -* ]] && { echo "Error: --data-source requires a value"; exit 1; }
+            REPORT_DATA_SOURCE="$2"
+            shift 2
+            ;;
         -*)
             echo "Unknown option: $1"
-            echo "Usage: $0 [output_file] [--write]"
+            echo "Usage: $0 [output_file] [--write] [--bench regex] [--packages pkg1,pkg2] [--benchtime duration] [--title title] [--scope scope] [--data-source source]"
             exit 1
             ;;
         *)
@@ -39,7 +75,7 @@ while [[ $# -gt 0 ]]; do
                 OUTPUT_FILE="$1"
                 OUTPUT_FILE_SET=true
             else
-                echo "Too many arguments. Usage: $0 [output_file] [--write]"
+                echo "Too many arguments. Usage: $0 [output_file] [--write] [--bench regex] [--packages pkg1,pkg2] [--benchtime duration] [--title title] [--scope scope] [--data-source source]"
                 exit 1
             fi
             shift
@@ -55,7 +91,7 @@ OS=$(uname -s)
 ARCH=$(uname -m)
 CPU_CORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo "unknown")
 
-echo "Running all Dingo benchmarks..."
+echo "Running Dingo benchmarks..."
 echo "==============================="
 
 # Run benchmarks with progress output first
@@ -65,12 +101,17 @@ echo "Executing benchmarks (this may take a few minutes)..."
 set -o pipefail
 
 # Run go test once, capture output while showing progress
-BENCHMARK_OUTPUT=$(go test -bench=. -benchmem ./... -run=^$ 2>&1)
+IFS=',' read -r -a BENCHMARK_PACKAGE_ARGS <<< "$BENCH_PACKAGES"
+BENCHMARK_ARGS=(-bench="$BENCH_REGEX" -benchmem -run=^$)
+if [[ -n "$BENCH_TIME" ]]; then
+    BENCHMARK_ARGS+=("-benchtime=$BENCH_TIME")
+fi
+BENCHMARK_OUTPUT=$(go test "${BENCHMARK_ARGS[@]}" "${BENCHMARK_PACKAGE_ARGS[@]}" 2>&1)
 GO_TEST_EXIT_CODE=$?
 
 # Show progress by parsing benchmark names from output
 echo "$BENCHMARK_OUTPUT" | grep "^Benchmark" | sed 's/Benchmark//' | sed 's/-[0-9]*$//' | while read -r name rest; do
-    echo "Running: $name-128"
+    echo "Running: $name"
 done
 
 # Check if go test succeeded
@@ -90,18 +131,52 @@ parse_benchmark() {
     local line="$1"
     local name
     name=$(echo "$line" | awk '{print $1}' | sed 's/Benchmark//' | sed 's/-[0-9]*$//')
-    local ops_sec
-    ops_sec=$(echo "$line" | awk '{print $2}' | sed 's/,//g')
+    local iterations
+    iterations=$(echo "$line" | awk '{print $2}' | sed 's/,//g')
     local time_val
     time_val=$(echo "$line" | awk '{print $3}')
     local time_unit
     time_unit=$(echo "$line" | awk '{print $4}')
-    local mem_val
-    mem_val=$(echo "$line" | awk '{print $5}')
-    local mem_unit
-    mem_unit=$(echo "$line" | awk '{print $6}')
-    local allocs_op
-    allocs_op=$(echo "$line" | awk '{print $7}')
+
+    local extra_metrics=""
+    local mem_op="N/A"
+    local allocs_op="N/A"
+    local idx=5
+    local token_count
+    token_count=$(echo "$line" | awk '{print NF}')
+
+    while [[ $idx -le $token_count ]]; do
+        local metric_val
+        metric_val=$(echo "$line" | awk -v i="$idx" '{print $i}')
+        local metric_unit
+        metric_unit=$(echo "$line" | awk -v i="$((idx + 1))" '{print $i}')
+
+        if [[ -z "$metric_val" || -z "$metric_unit" ]]; then
+            break
+        fi
+
+        case "$metric_unit" in
+            "B/op")
+                if [[ "$metric_val" =~ ^[0-9]+$ && $metric_val -gt 1000 ]]; then
+                    mem_kb=$((metric_val / 1000))
+                    mem_op="${mem_kb}KB"
+                else
+                    mem_op="${metric_val}B"
+                fi
+                ;;
+            "allocs/op")
+                allocs_op="$metric_val"
+                ;;
+            *)
+                if [[ -n "$extra_metrics" ]]; then
+                    extra_metrics="${extra_metrics}, "
+                fi
+                extra_metrics="${extra_metrics}${metric_val} ${metric_unit}"
+                ;;
+        esac
+
+        idx=$((idx + 2))
+    done
 
     # Format time
     if [[ "$time_unit" == "ns/op" ]]; then
@@ -116,62 +191,74 @@ parse_benchmark() {
         time_op="${time_val}${time_unit}"
     fi
 
-    # Format memory
-    if [[ "$mem_unit" == "B/op" ]]; then
-        if [[ $mem_val -gt 1000 ]]; then
-            mem_kb=$((mem_val / 1000))
-            mem_op="${mem_kb}KB"
-        else
-            mem_op="${mem_val}B"
-        fi
-    else
-        mem_op="${mem_val}${mem_unit}"
+    if [[ -z "$extra_metrics" ]]; then
+        extra_metrics="-"
     fi
 
     # Format benchmark name nicely
     formatted_name=$(echo "$name" | sed 's/\([A-Z]\)/ \1/g' | sed 's/^ //' | sed 's/NoData$/ (No Data)/' | sed 's/RealData$/ (Real Data)/')
 
-    echo "$formatted_name|$ops_sec|$time_op|$mem_op|$allocs_op"
+    echo "$formatted_name|$iterations|$time_op|$extra_metrics|$mem_op|$allocs_op"
 }
 
-# Parse current results into temporary file
+# Parse current results into temporary file, tracking current package
+# go test outputs "pkg: <import-path>" before each package's benchmarks
 CURRENT_RESULTS_FILE=$(mktemp "${TMPDIR:-/tmp}/dingo_bench_XXXXXX")
+current_pkg=""
 while IFS= read -r line; do
-    if [[ "$line" =~ ^Benchmark ]]; then
+    if [[ "$line" =~ ^pkg:[[:space:]]+(.+)$ ]]; then
+        current_pkg="${BASH_REMATCH[1]}"
+    elif [[ "$line" =~ ^ok[[:space:]] || "$line" =~ ^FAIL[[:space:]] ]]; then
+        current_pkg=""
+    elif [[ "$line" =~ ^Benchmark ]]; then
         parsed=$(parse_benchmark "$line")
         name=$(echo "$parsed" | cut -d'|' -f1)
         data=$(echo "$parsed" | cut -d'|' -f2-)
-        echo "$name|$data" >> "$CURRENT_RESULTS_FILE"
+        if [[ -n "$current_pkg" ]]; then
+            pkg_short=$(basename "$current_pkg")
+            echo "${pkg_short}:${name}|$data" >> "$CURRENT_RESULTS_FILE"
+        else
+            echo "$name|$data" >> "$CURRENT_RESULTS_FILE"
+        fi
     fi
 done <<< "$BENCHMARK_OUTPUT"
 
-# Deduplicate benchmark names
+# Deduplicate benchmark names (composite key: package+benchmark)
 sort -t'|' -k1,1 -u "$CURRENT_RESULTS_FILE" > "$CURRENT_RESULTS_FILE.tmp" && mv "$CURRENT_RESULTS_FILE.tmp" "$CURRENT_RESULTS_FILE"
 
 # Display current results summary
 echo "Current Benchmark Summary"
 echo "-------------------------"
-echo "Fastest benchmarks (>100k ops/sec):"
-echo "$BENCHMARK_OUTPUT" | grep "^Benchmark" | sort -k2 -nr | head -3 | while read -r line; do
-    name=$(echo "$line" | awk '{print $1}' | sed 's/Benchmark//' | sed 's/-128$//')
-    ops=$(echo "$line" | awk '{print $2}' | sed 's/,//g')
-    echo "  - $name: ${ops} ops/sec"
+echo "Most iterations (>100k iters):"
+sort -t'|' -k2,2nr "$CURRENT_RESULTS_FILE" | head -3 | while IFS='|' read -r name iterations _; do
+    echo "  - $name: ${iterations} iterations"
 done
 
 echo ""
-echo "Slowest benchmarks (<1k ops/sec):"
-echo "$BENCHMARK_OUTPUT" | grep "^Benchmark" | awk '$2 < 1000' | while read -r line; do
-    name=$(echo "$line" | awk '{print $1}' | sed 's/Benchmark//' | sed 's/-128$//')
-    ops=$(echo "$line" | awk '{print $2}' | sed 's/,//g')
-    echo "  - $name: ${ops} ops/sec"
+echo "Fewest iterations (<1k iters):"
+awk -F'|' '$2 < 1000 {print $1 "|" $2}' "$CURRENT_RESULTS_FILE" | while IFS='|' read -r name iterations; do
+    echo "  - $name: ${iterations} iterations"
 done
 
 echo ""
 echo "Memory usage:"
-echo "$BENCHMARK_OUTPUT" | grep "^Benchmark" | sort -k5 -nr | head -3 | while read -r line; do
-    name=$(echo "$line" | awk '{print $1}' | sed 's/Benchmark//' | sed 's/-128$//')
-    mem=$(echo "$line" | awk '{print $5}')
-    echo "  - $name: ${mem}B per op"
+awk -F'|' '
+function mem_bytes(v) {
+    if (v ~ /KB$/) {
+        sub(/KB$/, "", v)
+        return v + 0
+    }
+    if (v ~ /B$/) {
+        sub(/B$/, "", v)
+        return (v + 0) / 1000
+    }
+    return -1
+}
+{
+    print mem_bytes($5) "|" $1 "|" $5
+}
+' "$CURRENT_RESULTS_FILE" | sort -t'|' -k1,1nr | head -3 | while IFS='|' read -r _ name mem; do
+    echo "  - $name: ${mem} per op"
 done
 
 # Read previous results if file exists and we're comparing
@@ -193,19 +280,39 @@ if [[ -f "$OUTPUT_FILE" && "$WRITE_TO_FILE" == "true" ]]; then
         if [[ "$line" == "## Performance Changes" || "$line" == "## Historical Results" ]]; then
             break
         fi
-        if [[ "$line" == "| Benchmark | Operations/sec | Time/op | Memory/op | Allocs/op |" ]]; then
+        if [[ "$line" == "| Benchmark | Operations/sec | Time/op | Memory/op | Allocs/op |" ||
+              "$line" == "| Benchmark | Iterations | Time/op | Extra Metrics | Memory/op | Allocs/op |" ]]; then
             in_table=true
             continue
         fi
-        if [[ "$in_table" == true && "$line" =~ ^\|.*\|.*\|.*\|.*\|.*\|$ && "$line" != "|-----------|*" ]]; then
+        # Skip separator rows (e.g. |---|---|...)
+        if [[ "$line" =~ ^\|[-[:space:]\|]+\|$ ]]; then
+            continue
+        fi
+        if [[ "$in_table" == true && "$line" =~ ^\|.*\|.*\|.*\|.*\|.*\|$ ]]; then
             # Parse table row
             benchmark=$(echo "$line" | sed 's/^| //' | cut -d'|' -f1 | sed 's/ *$//')
-            ops_sec=$(echo "$line" | sed 's/^| //' | cut -d'|' -f2 | sed 's/ //g' | sed 's/,//g')
-            time_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f3 | sed 's/ //g')
-            mem_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f4 | sed 's/ //g')
-            allocs_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f5 | sed 's/ //g')
-            if [[ -n "$benchmark" && -n "$ops_sec" ]]; then
-                echo "$benchmark|$ops_sec|$time_op|$mem_op|$allocs_op" >> "$PREVIOUS_RESULTS_FILE"
+            # Count fields to detect 5-column vs 6-column format
+            field_count=$(echo "$line" | awk -F'|' '{print NF - 2}')
+
+            if [[ "$field_count" -le 5 ]]; then
+                # Old 5-column format: Benchmark | Operations/sec | Time/op | Memory/op | Allocs/op
+                iterations="-"
+                time_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f3 | sed 's/ //g')
+                extra_metrics=$(echo "$line" | sed 's/^| //' | cut -d'|' -f2 | sed 's/^ *//' | sed 's/ *$//')
+                mem_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f4 | sed 's/ //g')
+                allocs_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f5 | sed 's/ //g')
+            else
+                # Current 6-column format
+                iterations=$(echo "$line" | sed 's/^| //' | cut -d'|' -f2 | sed 's/ //g' | sed 's/,//g')
+                time_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f3 | sed 's/ //g')
+                extra_metrics=$(echo "$line" | sed 's/^| //' | cut -d'|' -f4 | sed 's/^ *//' | sed 's/ *$//')
+                mem_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f5 | sed 's/ //g')
+                allocs_op=$(echo "$line" | sed 's/^| //' | cut -d'|' -f6 | sed 's/ //g')
+            fi
+
+            if [[ -n "$benchmark" && -n "$time_op" ]]; then
+                echo "$benchmark|$iterations|$time_op|$extra_metrics|$mem_op|$allocs_op" >> "$PREVIOUS_RESULTS_FILE"
             fi
         fi
         if [[ "$in_table" == true && "$line" == "" ]]; then
@@ -251,16 +358,16 @@ if [[ -n "$previous_date" && "$WRITE_TO_FILE" == "true" ]]; then
             current_data=$(get_current_data "$benchmark")
             previous_data=$(get_previous_data "$benchmark")
 
-            current_ops=$(echo "$current_data" | cut -d'|' -f1)
-            previous_ops=$(echo "$previous_data" | cut -d'|' -f1)
+            current_iters=$(echo "$current_data" | cut -d'|' -f1)
+            previous_iters=$(echo "$previous_data" | cut -d'|' -f1)
 
-            if [[ "$current_ops" =~ ^[0-9]+$ && "$previous_ops" =~ ^[0-9]+$ && $previous_ops -gt 0 ]]; then
-                change=$(( (current_ops - previous_ops) * 100 / previous_ops ))
+            if [[ "$current_iters" =~ ^[0-9]+$ && "$previous_iters" =~ ^[0-9]+$ && $previous_iters -gt 0 ]]; then
+                change=$(( (current_iters - previous_iters) * 100 / previous_iters ))
                 if [[ $change -gt 10 ]]; then
                     faster_benchmarks="$faster_benchmarks
 $benchmark (+${change}%)"
                 elif [[ $change -lt -10 ]]; then
-                    change_abs=$(( (previous_ops - current_ops) * 100 / previous_ops ))
+                    change_abs=$(( (previous_iters - current_iters) * 100 / previous_iters ))
                     slower_benchmarks="$slower_benchmarks
 $benchmark (-${change_abs}%)"
                     MAJOR_CHANGES=true
@@ -333,16 +440,16 @@ if [[ "$WRITE_TO_FILE" == "true" ]]; then
                     current_data=$(get_current_data "$benchmark")
                     previous_data=$(get_previous_data "$benchmark")
 
-                    current_ops=$(echo "$current_data" | cut -d'|' -f1)
-                    previous_ops=$(echo "$previous_data" | cut -d'|' -f1)
+                    current_iters=$(echo "$current_data" | cut -d'|' -f1)
+                    previous_iters=$(echo "$previous_data" | cut -d'|' -f1)
 
-                    if [[ "$current_ops" =~ ^[0-9]+$ && "$previous_ops" =~ ^[0-9]+$ && $previous_ops -gt 0 ]]; then
-                        if [[ $current_ops -gt $previous_ops ]]; then
-                            change=$(( (current_ops - previous_ops) * 100 / previous_ops ))
+                    if [[ "$current_iters" =~ ^[0-9]+$ && "$previous_iters" =~ ^[0-9]+$ && $previous_iters -gt 0 ]]; then
+                        if [[ $current_iters -gt $previous_iters ]]; then
+                            change=$(( (current_iters - previous_iters) * 100 / previous_iters ))
                             faster_benchmarks="$faster_benchmarks
 $benchmark (+${change}%)"
-                        elif [[ $current_ops -lt $previous_ops ]]; then
-                            change=$(( (previous_ops - current_ops) * 100 / previous_ops ))
+                        elif [[ $current_iters -lt $previous_iters ]]; then
+                            change=$(( (previous_iters - current_iters) * 100 / previous_iters ))
                             slower_benchmarks="$slower_benchmarks
 $benchmark (-${change}%)"
                         fi
@@ -401,7 +508,7 @@ $benchmark"
 
         # Create the markdown file
         cat > "$OUTPUT_FILE.tmp" << EOF
-# Dingo Ledger & Database Benchmark Results
+# $REPORT_TITLE
 
 ## Latest Results
 
@@ -411,24 +518,34 @@ $benchmark"
 - **OS**: $OS
 - **Architecture**: $ARCH
 - **CPU Cores**: $CPU_CORES
-- **Data Source**: Real Cardano preview testnet data (40k+ blocks, slots 0-863,996)
+- **Data Source**: $REPORT_DATA_SOURCE
+EOF
+
+        if [[ -n "$REPORT_SCOPE" ]]; then
+            cat >> "$OUTPUT_FILE.tmp" << EOF
+- **Scope**: $REPORT_SCOPE
+EOF
+        fi
+
+        cat >> "$OUTPUT_FILE.tmp" << EOF
 
 ### Benchmark Results
 
-All benchmarks run with \`-benchmem\` flag showing memory allocations and operation counts.
+All benchmarks run with \`-benchmem\` flag. Iterations are Go benchmark iteration counts; benchmark-specific throughput metrics (for example \`blocks/sec\`) are reported separately.
 
-| Benchmark | Operations/sec | Time/op | Memory/op | Allocs/op |
-|-----------|----------------|---------|-----------|-----------|
+| Benchmark | Iterations | Time/op | Extra Metrics | Memory/op | Allocs/op |
+|-----------|------------|---------|---------------|-----------|-----------|
 EOF
 
         # Add current results to table
         while IFS= read -r benchmark; do
             data=$(get_current_data "$benchmark")
-            ops_sec=$(echo "$data" | cut -d'|' -f1)
+            iterations=$(echo "$data" | cut -d'|' -f1)
             time_op=$(echo "$data" | cut -d'|' -f2)
-            mem_op=$(echo "$data" | cut -d'|' -f3)
-            allocs_op=$(echo "$data" | cut -d'|' -f4)
-            echo "| $benchmark | $ops_sec | $time_op | $mem_op | $allocs_op |" >> "$OUTPUT_FILE.tmp"
+            extra_metrics=$(echo "$data" | cut -d'|' -f3)
+            mem_op=$(echo "$data" | cut -d'|' -f4)
+            allocs_op=$(echo "$data" | cut -d'|' -f5)
+            echo "| $benchmark | $iterations | $time_op | $extra_metrics | $mem_op | $allocs_op |" >> "$OUTPUT_FILE.tmp"
         done < <(list_current_benchmarks)
 
         # Add comparison section
@@ -441,17 +558,18 @@ EOF
             echo "" >> "$OUTPUT_FILE.tmp"
             echo "### $previous_date" >> "$OUTPUT_FILE.tmp"
             echo "" >> "$OUTPUT_FILE.tmp"
-            echo "| Benchmark | Operations/sec | Time/op | Memory/op | Allocs/op |" >> "$OUTPUT_FILE.tmp"
-            echo "|-----------|----------------|---------|-----------|-----------|" >> "$OUTPUT_FILE.tmp"
+            echo "| Benchmark | Iterations | Time/op | Extra Metrics | Memory/op | Allocs/op |" >> "$OUTPUT_FILE.tmp"
+            echo "|-----------|------------|---------|---------------|-----------|-----------|" >> "$OUTPUT_FILE.tmp"
 
             # Add previous results
             while IFS= read -r benchmark; do
                 data=$(get_previous_data "$benchmark")
-                ops_sec=$(echo "$data" | cut -d'|' -f1)
+                iterations=$(echo "$data" | cut -d'|' -f1)
                 time_op=$(echo "$data" | cut -d'|' -f2)
-                mem_op=$(echo "$data" | cut -d'|' -f3)
-                allocs_op=$(echo "$data" | cut -d'|' -f4)
-                echo "| $benchmark | $ops_sec | $time_op | $mem_op | $allocs_op |" >> "$OUTPUT_FILE.tmp"
+                extra_metrics=$(echo "$data" | cut -d'|' -f3)
+                mem_op=$(echo "$data" | cut -d'|' -f4)
+                allocs_op=$(echo "$data" | cut -d'|' -f5)
+                echo "| $benchmark | $iterations | $time_op | $extra_metrics | $mem_op | $allocs_op |" >> "$OUTPUT_FILE.tmp"
             done < <(list_previous_benchmarks)
         fi
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blinklabs/dingo",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Dingo is a Cardano blockchain data node",
   "main": "index.js",
   "bin": {