diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 00000000..6d54c5ee --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,11 @@ +# Default owner fallback. +* @monstercameron + +# Release and CI automation are protected surfaces. +/.github/workflows/ @monstercameron + +# Transport/runtime library changes require explicit owner review. +/third_party/GoGRPCBridge/ @monstercameron + +# Release-readiness roadmap and integration docs. +/docs/GOGRPCBRIDGE_*.md @monstercameron diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 00000000..946b6062 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,44 @@ +name: Bug report +description: A concrete, reproducible defect in the framework, runtime, or gwc tooling. +labels: ["bug", "needs-triage"] +body: + - type: markdown + attributes: + value: | + Thanks for the report. A **minimal reproduction** is the single most + useful thing you can include — the smallest `main.go` plus the `gwc` + command that triggers the problem. First-response target: 5 business + days (see CONTRIBUTING.md → Triage SLA). + - type: textarea + id: what-happened + attributes: + label: What happened + description: What did you observe, and what did you expect instead? + validations: + required: true + - type: textarea + id: repro + attributes: + label: Minimal reproduction + description: The smallest code + the exact `gwc`/`go` command that reproduces it. + render: shell + validations: + required: true + - type: input + id: versions + attributes: + label: Versions + description: "Output of `go version` and the GoWebComponents version/commit." + validations: + required: true + - type: dropdown + id: lane + attributes: + label: Where does it occur? + options: + - Browser (js/wasm) + - Server / SSR (native) + - gwc tooling + - Both / unsure + validations: + required: true diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 00000000..8048f2bb --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,13 @@ +# Issues are for concrete, reproducible defects. Questions, ideas, and show-and-tell go to +# Discussions; security reports follow the disclosure policy. +blank_issues_enabled: false +contact_links: + - name: Questions & Help (Q&A) + url: https://github.com/monstercameron/GoWebComponents/discussions/categories/q-a + about: Ask how to do something, or "is this a bug?" before filing an issue. + - name: Ideas & Feature Proposals + url: https://github.com/monstercameron/GoWebComponents/discussions/categories/ideas + about: Propose a feature or direction. Accepted ideas are linked from ROADMAP.md. + - name: Security Disclosure + url: https://github.com/monstercameron/GoWebComponents/security/policy + about: Report a vulnerability privately. Do NOT open a public issue. diff --git a/.github/workflows/agent-bridge-headless.yml b/.github/workflows/agent-bridge-headless.yml new file mode 100644 index 00000000..29b96f9c --- /dev/null +++ b/.github/workflows/agent-bridge-headless.yml @@ -0,0 +1,87 @@ +name: Agent Bridge Headless + +on: + pull_request: + paths: + - ".github/workflows/agent-bridge-headless.yml" + - "AGENTS.md" + - "agentbridge/**" + - "docs/REFERENCE_MANUAL/**" + - "examples/public-examples-site/assets/docs/**" + - "examples/server/ai-chat-wizard/**" + - "internal/runtime/**" + - "security/**" + - "test/playwrightgo/**" + - "tools/agenthub/**" + - "tools/gwc/**" + - "tools/livereload/**" + push: + branches: + - main + - master + paths: + - ".github/workflows/agent-bridge-headless.yml" + - "AGENTS.md" + - "agentbridge/**" + - "docs/REFERENCE_MANUAL/**" + - "examples/public-examples-site/assets/docs/**" + - "examples/server/ai-chat-wizard/**" + - "internal/runtime/**" + - "security/**" + - "test/playwrightgo/**" + - "tools/agenthub/**" + - "tools/gwc/**" + - "tools/livereload/**" + workflow_dispatch: + +permissions: + contents: read + +env: + PLAYWRIGHT_GO_VERSION: v0.5700.1 + +jobs: + bridge-headless: + name: Bridge Native + Headless Dogfood + runs-on: ubuntu-latest + timeout-minutes: 20 + + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Install Playwright Chromium + run: go run github.com/playwright-community/playwright-go/cmd/playwright@${{ env.PLAYWRIGHT_GO_VERSION }} install --with-deps chromium + + - name: Run native agent bridge lane + run: go run ./tools/gwc test -lane agent -json + + - name: Prebuild agent dogfood client + run: | + mkdir -p examples/server/ai-chat-wizard/bin/client/app + GOOS=js GOARCH=wasm go build -tags gwcagent -o examples/server/ai-chat-wizard/bin/client/app/chat.wasm ./examples/server/ai-chat-wizard/client + + - name: Prebuild agent dogfood server + run: | + mkdir -p bin/ci + go build -o bin/ci/example100-agent-dogfood-server ./examples/server/ai-chat-wizard/cmd/server + + - name: Run headless agent bridge dogfood lane + env: + GWC_AGENT_DOGFOOD_REUSE_CLIENT_WASM: "1" + GWC_AGENT_DOGFOOD_SERVER_BINARY: bin/ci/example100-agent-dogfood-server + GWC_AGENT_DOGFOOD_TRACE: "1" + run: | + while sleep 20; do + echo "agent-browser dogfood still running..." + done & + keepalive_pid="$!" + trap 'kill "$keepalive_pid" 2>/dev/null || true' EXIT + go test -tags playwrightgo -run 'TestExample100AgentBridgeDogfood|TestAgentBridgeDogfood|TestAgentBridgeHeadless' -count=1 -timeout=5m -v ./test/playwrightgo/examples diff --git a/.github/workflows/api-baseline.yml b/.github/workflows/api-baseline.yml new file mode 100644 index 00000000..06bf9b99 --- /dev/null +++ b/.github/workflows/api-baseline.yml @@ -0,0 +1,39 @@ +name: API Baseline + +# F3 merge gate: the public-API baseline tests run on every PR (and push to main), so an +# accidental breaking change to an exported surface fails BEFORE merge — not only at release +# tag time. This makes the major/minor boundary (VERSIONING.md) mechanically enforced: a removed +# or changed baseline line fails the gate; an intentional change regenerates the baseline +# (UPDATE_API_BASELINE=1 go test .//) as a reviewed commit. + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + api-baseline: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Public-API baseline gate + # No continue-on-error: any exported-surface drift fails the PR. Covers every package + # whose public API is pinned with an api_baseline.txt. + run: | + go test -count=1 \ + ./serverfn/ ./query/ ./localfirst/ ./agentui/ ./validate/ \ + ./anim/ ./timetravel/ ./workbench/ ./wholestack/ \ + -run 'APIBaseline|ApiBaseline|API_BASELINE' diff --git a/.github/workflows/bench-drift.yml b/.github/workflows/bench-drift.yml new file mode 100644 index 00000000..106b5d16 --- /dev/null +++ b/.github/workflows/bench-drift.yml @@ -0,0 +1,37 @@ +name: Bench Drift + +# D3 merge gate: a benchmark that regresses beyond the tolerance fails the build, so a +# performance regression cannot land silently. The run compares the fresh native benchmark +# numbers against the committed baseline (docs/benchmarks/latest.json) and exits non-zero on any +# out-of-tolerance regression via `gwc bench -fail-on-regression`. Benchmarks are pinned to a +# single package run (-parallel 1) for the lowest-noise comparison. + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + bench-drift: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Build gwc + run: go build -o gwc ./tools/gwc + + - name: Benchmark drift gate (native lane) + # Compares against the committed baseline and fails on any out-of-tolerance regression. + run: ./gwc bench -lane native -parallel 1 -fail-on-regression diff --git a/.github/workflows/browser-compatibility.yml b/.github/workflows/browser-compatibility.yml new file mode 100644 index 00000000..e8abb6a5 --- /dev/null +++ b/.github/workflows/browser-compatibility.yml @@ -0,0 +1,30 @@ +name: Browser Compatibility + +on: + push: + branches: + - main + - master + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + compatibility-smoke: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Run Browser Compatibility Smoke (Playwright-Go) + run: | + go test -tags playwrightgo ./test/playwrightgo/examples -run TestBrowserCompat -v diff --git a/.github/workflows/build-times.yml b/.github/workflows/build-times.yml new file mode 100644 index 00000000..ee88704d --- /dev/null +++ b/.github/workflows/build-times.yml @@ -0,0 +1,53 @@ +name: Build Times + +# A2/C2 platform-honest gate: publishes the cold-vs-warm build-time pair and fails the build if +# the Go build cache stops delivering a speedup (warm rebuild slower than -max-warm-ratio of the +# cold build). CI starts from a cold cache, so the cold/warm differential is real and meaningful. +# The gate targets the WASM build of a representative app (the workload A2/C2 actually care about — +# wasm compile time, not the native CLI), recomputes timings fresh each run, and gates on the +# machine-independent warm/cold ratio (absolute ms vary by hardware). The committed +# docs/benchmarks/build-times.json is a portable reference snapshot; the gate does not depend on +# it, so it cannot silently drift the build green/red — the fresh artifact is uploaded each run. + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + build-times: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Build gwc + run: go build -o gwc ./tools/gwc + + - name: Cold/warm WASM build-time gate + # Cold wasm build (CI cache is empty) then an immediate warm rebuild of the counter app; + # fails if the warm rebuild is not at least 40% faster than the cold one + # (-max-warm-ratio 0.6), proving the build cache delivers for the wasm target. Writes the + # fresh report to docs/benchmarks/build-times.json (uploaded below). + run: | + ./gwc warm -once -target wasm -pattern ./examples/public/counter \ + -baseline docs/benchmarks/build-times.json \ + -max-warm-ratio 0.6 -fail-on-regression -json + + - name: Upload build-time report + if: always() + uses: actions/upload-artifact@v4 + with: + name: build-times + path: docs/benchmarks/build-times.json diff --git a/.github/workflows/catalog-smoke.yml b/.github/workflows/catalog-smoke.yml new file mode 100644 index 00000000..f556e43f --- /dev/null +++ b/.github/workflows/catalog-smoke.yml @@ -0,0 +1,72 @@ +name: Catalog Smoke + +# FA3: prove every `gwc add` catalog component compiles AFTER being copied into a fresh module +# (not just in-repo). For each component we scaffold a throwaway module that requires the local +# GoWebComponents via a replace directive, `gwc add` the component, write a tiny consumer, and +# `go build` it. A template that does not compile standalone fails the gate. + +on: + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + catalog-smoke: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Build gwc + run: go build -o gwc ./tools/gwc + + - name: gwc add → go build each catalog component + shell: bash + run: | + repo="$(pwd)" + for name in alert breadcrumb disclosure switch tabs; do + work="$(mktemp -d)" + ( cd "$work" + go mod init example.com/catalog-smoke + echo "require github.com/monstercameron/GoWebComponents v0.0.0" >> go.mod + echo "replace github.com/monstercameron/GoWebComponents => $repo" >> go.mod + mkdir -p uikit + "$repo/gwc" add "$name" -dir ./uikit -pkg uikit + # Tiny consumer so the package is actually compiled, not just present. + printf 'package main\nimport _ "example.com/catalog-smoke/uikit"\nfunc main() {}\n' > main.go + go mod tidy + echo "Building catalog component: $name" + go build ./... + ) + rm -rf "$work" + done + + - name: gwc add component/route generators → go build + # A3 10-rung "CI-verified": the composable sub-generators must also produce compiling code + # in a fresh module, not just parse. Scaffold a component and a route into a throwaway + # module and build them. + shell: bash + run: | + repo="$(pwd)" + work="$(mktemp -d)" + ( cd "$work" + go mod init example.com/generator-smoke + echo "require github.com/monstercameron/GoWebComponents v0.0.0" >> go.mod + echo "replace github.com/monstercameron/GoWebComponents => $repo" >> go.mod + "$repo/gwc" add component MyWidget -dir ./ui -pkg ui + "$repo/gwc" add route Home -path /home -dir ./ui -pkg ui + printf 'package main\nimport _ "example.com/generator-smoke/ui"\nfunc main() {}\n' > main.go + go mod tidy + echo "Building generated component + route" + go build ./... + ) + rm -rf "$work" diff --git a/.github/workflows/doc-samples.yml b/.github/workflows/doc-samples.yml new file mode 100644 index 00000000..3066d088 --- /dev/null +++ b/.github/workflows/doc-samples.yml @@ -0,0 +1,33 @@ +name: Doc Samples + +# F1 type-level gate: every `gwc:build`-marked complete-file Go sample in the docs is COMPILED +# against the real module (written to a throwaway module with a replace → repo, then `go build`). +# This catches the failure the parse-gate cannot — a runnable sample that still parses but uses a +# renamed/removed API. The fast parse-gate (TestDocsHaveNoBrokenGoSamples) runs in the normal +# `go test ./...` lane; this heavier compile gate runs here, behind the `doccompile` build tag. + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + doc-samples: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Compile gwc:build-marked doc samples + run: go test -tags doccompile ./docs/doclint -run TestDocsMarkedSamplesCompile -count=1 -v -timeout 10m diff --git a/.github/workflows/doclint-commands.yml b/.github/workflows/doclint-commands.yml new file mode 100644 index 00000000..c6817147 --- /dev/null +++ b/.github/workflows/doclint-commands.yml @@ -0,0 +1,27 @@ +name: Doclint Command Execution + +on: + workflow_dispatch: + +permissions: + contents: read + +jobs: + doclint-commands: + runs-on: windows-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + fetch-depth: 0 + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Execute Documented GWC Commands + run: | + go test -tags doclintcmd ./docs/doclint -run TestDocsGwcCommandsExecute -count=1 -v -timeout 10m + shell: pwsh diff --git a/.github/workflows/doctor-parity.yml b/.github/workflows/doctor-parity.yml new file mode 100644 index 00000000..97e14fe3 --- /dev/null +++ b/.github/workflows/doctor-parity.yml @@ -0,0 +1,42 @@ +name: Doctor Parity + +# Earns the A1 "platform-honest" claim: `gwc doctor` and its --fix remediations must work +# identically on Linux, macOS, and Windows. The doctor/check fixers touch build constraints, +# file paths, and gofmt — all places where OS differences (path separators, line endings) bite — +# so they are exercised on every supported OS, not just Linux. + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + doctor-parity: + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + runs-on: ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Build gwc + run: go build -o gwc ./tools/gwc + + - name: Doctor + check fixer unit tests (cross-OS) + run: go test ./tools/gwc/ -run "Doctor|ScaffoldMetadata|CheckFix|ServerLeak|Vuln" -count=1 + + - name: gwc doctor smoke (self-repo) + run: go run ./tools/gwc doctor -json diff --git a/.github/workflows/examples-build.yml b/.github/workflows/examples-build.yml new file mode 100644 index 00000000..ade4346e --- /dev/null +++ b/.github/workflows/examples-build.yml @@ -0,0 +1,38 @@ +name: Examples Build + +# F2 merge gate: every public example must compile for the browser target, so a framework API +# change that breaks an example fails CI before merge (not just the catalog index's existence +# guards). The examples live in the repo module, so the wasm build resolves against the repo's +# own go.sum with no network. Complements docs/capabilities (the machine-verified API→example +# index) and catalog-smoke (the `gwc add` copy-out path). + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + examples-build: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Build all public examples (wasm) + # Public examples are browser apps; they live in the repo module so this resolves with no + # network. Proven to pass across all 113 example mains. + env: + GOOS: js + GOARCH: wasm + run: go build ./examples/public/... diff --git a/.github/workflows/gogrpcbridge-ci.yml b/.github/workflows/gogrpcbridge-ci.yml new file mode 100644 index 00000000..adbc98d4 --- /dev/null +++ b/.github/workflows/gogrpcbridge-ci.yml @@ -0,0 +1,298 @@ +name: GoGRPCBridge CI + +on: + pull_request: + paths: + - ".github/workflows/gogrpcbridge-ci.yml" + - "docs/GOGRPCBRIDGE_*.md" + - "go.mod" + - "go.sum" + - "scripts/bootstrap-gogrpcbridge.ps1" + - "third_party/GoGRPCBridge/**" + - "examples/server/ai-chat-wizard/**" + push: + branches: + - main + - master + paths: + - ".github/workflows/gogrpcbridge-ci.yml" + - "docs/GOGRPCBRIDGE_*.md" + - "go.mod" + - "go.sum" + - "scripts/bootstrap-gogrpcbridge.ps1" + - "third_party/GoGRPCBridge/**" + - "examples/server/ai-chat-wizard/**" + workflow_dispatch: + +permissions: + contents: read + +env: + GOLANGCI_LINT_VERSION: v1.64.8 + GOSEC_VERSION: v2.25.0 + GOVULNCHECK_VERSION: v1.1.4 + PLAYWRIGHT_GO_VERSION: v0.5200.1 + +jobs: + gogrpcbridge-lint: + name: Lint Lane + runs-on: ubuntu-latest + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Install golangci-lint + run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@${{ env.GOLANGCI_LINT_VERSION }} + + - name: Run bridge lint lane + run: go run ./third_party/GoGRPCBridge/tools/runner.go lint + + gogrpcbridge-security: + name: Security Scan + runs-on: ubuntu-latest + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Install security scanners + run: | + go install github.com/securego/gosec/v2/cmd/gosec@${{ env.GOSEC_VERSION }} + go install golang.org/x/vuln/cmd/govulncheck@${{ env.GOVULNCHECK_VERSION }} + + - name: Run gosec (fail on HIGH severity + HIGH confidence) + run: | + cd ./third_party/GoGRPCBridge + # Keep generated-code exception for G103 in broad scan. + gosec -severity high -confidence high -exclude G103 ./... + # Enforce G103 in first-party code paths where unsafe usage is not expected. + gosec -severity high -confidence high -include G103 ./pkg/... ./examples/... ./e2e/... ./tools/... + + - name: Run govulncheck (reachable vulnerabilities fail) + run: | + cd ./third_party/GoGRPCBridge + govulncheck ./... + + gogrpcbridge-api-governance: + name: API Governance + runs-on: ubuntu-latest + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Run API compatibility and migration-policy guard + run: | + cd ./third_party/GoGRPCBridge + go run ./tools/api_compat_guard check + + gogrpcbridge-unit: + name: Unit Lane + runs-on: ubuntu-latest + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Run bridge unit lane + run: go run ./third_party/GoGRPCBridge/tools/runner.go test-short + + gogrpcbridge-wasm: + name: WASM Lane + runs-on: ubuntu-latest + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Run bridge wasm compile lane + run: go run ./third_party/GoGRPCBridge/tools/runner.go build + + gogrpcbridge-browser: + name: Browser Lane + runs-on: ubuntu-latest + if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'gogrpcbridge-full-gate') + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Install Playwright browsers + run: go run github.com/playwright-community/playwright-go/cmd/playwright@${{ env.PLAYWRIGHT_GO_VERSION }} install --with-deps chromium + + - name: Run bridge browser lane + run: go run ./third_party/GoGRPCBridge/tools/runner.go e2e + + gogrpcbridge-integration-smoke: + name: Root Integration Smoke + runs-on: ubuntu-latest + needs: + - gogrpcbridge-lint + - gogrpcbridge-security + - gogrpcbridge-api-governance + - gogrpcbridge-unit + - gogrpcbridge-wasm + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Verify module replacement wiring + run: go list -m github.com/monstercameron/GoGRPCBridge + + - name: Run root consumer smoke tests + run: | + go test ./examples/server/ai-chat-wizard/client/app -run TestDoesNotExist -count=1 + go test ./examples/server/ai-chat-wizard/server/app -run TestTransportHelpersCoverTunnelAndWasmResolution -count=1 + + gogrpcbridge-go-get-smoke: + name: Go Get Smoke + runs-on: ubuntu-latest + + steps: + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Run clean-consumer go-get smoke test + run: | + set -euo pipefail + WORK_DIR="$(mktemp -d)" + trap 'rm -rf "$WORK_DIR"' EXIT + cd "$WORK_DIR" + go mod init example.com/gogrpcbridge-get-smoke + go get github.com/monstercameron/GoGRPCBridge@latest + + gogrpcbridge-fast-pr-gate: + name: Fast PR Gate + runs-on: ubuntu-latest + if: github.event_name == 'pull_request' + needs: + - gogrpcbridge-lint + - gogrpcbridge-security + - gogrpcbridge-api-governance + - gogrpcbridge-unit + - gogrpcbridge-wasm + - gogrpcbridge-integration-smoke + - gogrpcbridge-go-get-smoke + + steps: + - name: Report fast lane success + run: | + echo "Fast PR gate passed:" + echo "- lint" + echo "- security" + echo "- api governance" + echo "- unit" + echo "- wasm" + echo "- root integration smoke" + echo "- go-get smoke" + + gogrpcbridge-benchmark-trend: + name: Benchmark Trend Lane + runs-on: ubuntu-latest + if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'gogrpcbridge-full-gate') + needs: + - gogrpcbridge-unit + + steps: + - name: Checkout repository with submodules + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Set up Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Run benchmark trend comparison + run: go run ./third_party/GoGRPCBridge/tools/runner.go quality-trend + + - name: Upload benchmark trend summary + if: always() + uses: actions/upload-artifact@v7 + with: + name: gogrpcbridge-benchmark-trend + path: third_party/GoGRPCBridge/bin/quality/trend.json + if-no-files-found: warn + + gogrpcbridge-full-gate: + name: Full Gate + runs-on: ubuntu-latest + if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'gogrpcbridge-full-gate') + needs: + - gogrpcbridge-lint + - gogrpcbridge-security + - gogrpcbridge-api-governance + - gogrpcbridge-unit + - gogrpcbridge-wasm + - gogrpcbridge-browser + - gogrpcbridge-integration-smoke + - gogrpcbridge-go-get-smoke + - gogrpcbridge-benchmark-trend + + steps: + - name: Report full gate success + run: | + echo "Full gate passed:" + echo "- lint" + echo "- security" + echo "- api governance" + echo "- unit" + echo "- wasm" + echo "- browser" + echo "- root integration smoke" + echo "- go-get smoke" + echo "- benchmark trend" diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml new file mode 100644 index 00000000..e848bed6 --- /dev/null +++ b/.github/workflows/pages.yml @@ -0,0 +1,77 @@ +name: Deploy Examples To Pages + +on: + push: + branches: + - main + - master + workflow_dispatch: + +permissions: + contents: read + pages: write + id-token: write + +concurrency: + group: github-pages + cancel-in-progress: true + +jobs: + build-pages: + runs-on: windows-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Setup Pages + uses: actions/configure-pages@v6 + + - name: Build Example WASM Files + shell: pwsh + run: | + go run ./tools/gwc examples build-public-site -profile ci + + - name: Prepare Pages Artifact + shell: pwsh + run: | + $pagesDir = Join-Path $PWD '.pages' + $examplesDir = Join-Path $PWD 'examples' + $pagesExampleDirs = @('public-examples-site', 'static') + + if (Test-Path $pagesDir) { + Remove-Item $pagesDir -Recurse -Force + } + + New-Item -ItemType Directory -Path $pagesDir | Out-Null + foreach ($exampleDir in $pagesExampleDirs) { + Copy-Item (Join-Path $examplesDir $exampleDir) $pagesDir -Recurse -Force + } + + New-Item -ItemType File -Path (Join-Path $pagesDir '.nojekyll') | Out-Null + + - name: Generate Static Docs Site + shell: pwsh + run: | + go run ./tools/sitegen -root . -out .pages + if ($LASTEXITCODE -ne 0) { throw "sitegen failed" } + + - name: Upload Pages Artifact + uses: actions/upload-pages-artifact@v5 + with: + path: .pages + + deploy-pages: + needs: build-pages + runs-on: ubuntu-latest + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Deploy To GitHub Pages + id: deployment + uses: actions/deploy-pages@v5 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 00000000..d36f5060 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,253 @@ +name: CI + Release + +on: + push: + tags: + - "v*.*.*" + workflow_dispatch: + inputs: + release_tag: + description: "Semver tag to release (vMAJOR.MINOR.PATCH)" + required: true + type: string + +permissions: + contents: write + attestations: write + id-token: write + +jobs: + build-and-test: + runs-on: windows-latest + permissions: + contents: read + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + fetch-depth: 0 + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Run Go Unit Tests + run: | + go test -short -v -count=1 ./... + shell: pwsh + + - name: Reproducible-Build Gate + # E2: the byte-identical reproducibility check is skipped under -short (it does two full + # wasm builds), so run it explicitly on the release path — provenance attestation is only + # meaningful if builds are actually reproducible. Not -short, scoped to the one package. + run: | + go test -run TestReproducibleWasmBuild -count=1 ./tools/reprobuild + shell: pwsh + + - name: Vulnerability Scan (govulncheck) + # Surfaces known vulnerabilities in the root module's call graph. + # This gate is blocking. Any accepted exception must be documented in + # security/govulncheck-suppressions.md and should have a tracked expiry. + run: | + go install golang.org/x/vuln/cmd/govulncheck@latest + & "$(go env GOPATH)\bin\govulncheck.exe" ./... + shell: pwsh + + - name: Generate CycloneDX SBOM + # Emits a dependency SBOM whose component list is derived from the + # resolved module graph (go list -m -json all), attachable to the release. + run: | + go run ./tools/sbom/cmd/sbom bin/sbom.cyclonedx.json + shell: pwsh + + - name: Upload CycloneDX SBOM + uses: actions/upload-artifact@v6 + with: + name: cyclonedx-sbom + path: bin/sbom.cyclonedx.json + if-no-files-found: error + + - name: CHANGELOG Entry Check + # Verifies the tag being released has a CHANGELOG.md section. This is a + # blocking release gate so tags do not ship with generated notes only. + run: | + $tag = if ($env:GITHUB_REF_NAME) { $env:GITHUB_REF_NAME } else { "${{ github.event.inputs.release_tag }}" } + go run ./tools/changelogcheck/cmd/changelogcheck CHANGELOG.md $tag + shell: pwsh + + - name: Run Golden-Path Verify Audit + run: | + go run ./tools/gwc verify -app .\examples\public\counter\main.go -root .\examples\public\counter -skip-tests -audit -audit-min-severity error + shell: pwsh + + - name: Run Browser Smoke Suite (Playwright-Go) + run: | + go test -tags playwrightgo ./test/playwrightgo -run TestMainSuite -v + shell: pwsh + + - name: Run Browser Benchmark Suite (Playwright-Go) + run: | + go test -tags playwrightgo ./test/playwrightgo -run TestBenchmark -v + shell: pwsh + + - name: Run Canonical Go Get Smoke (Release Guard) + run: | + $ErrorActionPreference = "Stop" + $workDir = Join-Path $env:TEMP ("gwc-release-smoke-" + [guid]::NewGuid().ToString("N")) + New-Item -ItemType Directory -Path $workDir | Out-Null + try { + Push-Location $workDir + go mod init example.com/gwc-release-smoke + if ($LASTEXITCODE -ne 0) { throw "go mod init failed" } + # Write a tiny external consumer that imports the released module, so the + # smoke proves go-get + import-path resolution + a real compile, not just + # that the module path resolves. Uses a long-stable symbol so '@latest' + # (the previously published tag during a tag push) always has it. + $main = @( + 'package main', + 'import "github.com/monstercameron/GoWebComponents/ui"', + 'var _ = ui.Text("release-smoke")', + 'func main() {}' + ) -join "`n" + Set-Content -Path (Join-Path $workDir "main.go") -Value $main -Encoding utf8 + go get github.com/monstercameron/GoWebComponents@latest + if ($LASTEXITCODE -ne 0) { throw "go get GoWebComponents@latest failed" } + go build ./... + if ($LASTEXITCODE -ne 0) { throw "native consumer build failed" } + $env:GOOS = "js"; $env:GOARCH = "wasm" + go build ./... + $wasmExit = $LASTEXITCODE + Remove-Item Env:GOOS; Remove-Item Env:GOARCH + if ($wasmExit -ne 0) { throw "wasm consumer build failed" } + } finally { + Pop-Location + if (Test-Path $workDir) { + Remove-Item -Recurse -Force $workDir + } + } + shell: pwsh + + release: + needs: build-and-test + runs-on: ubuntu-latest + permissions: + contents: write + attestations: write + id-token: write + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + fetch-depth: 0 + persist-credentials: true + + - name: Resolve Release Tag + id: tag + shell: bash + run: | + if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then + release_tag="${{ github.event.inputs.release_tag }}" + else + release_tag="${GITHUB_REF_NAME}" + fi + + if ! [[ "${release_tag}" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then + echo "invalid release tag: ${release_tag}" + exit 1 + fi + echo "release_tag=${release_tag}" >> "$GITHUB_OUTPUT" + + - name: Download CycloneDX SBOM + uses: actions/download-artifact@v6 + with: + name: cyclonedx-sbom + path: release-assets + + - name: Create Tag For Manual Release + if: github.event_name == 'workflow_dispatch' + env: + RELEASE_TAG: ${{ steps.tag.outputs.release_tag }} + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + shell: bash + run: | + if git rev-parse "$RELEASE_TAG" >/dev/null 2>&1; then + echo "Tag $RELEASE_TAG already exists. Skipping." + exit 0 + fi + + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + + git tag "$RELEASE_TAG" + git push origin "$RELEASE_TAG" + + - name: Build Release Archive + id: archive + shell: bash + run: | + release_tag="${{ steps.tag.outputs.release_tag }}" + archive_name="GoWebComponents-${release_tag}.tar.gz" + git archive --format=tar.gz --output "${archive_name}" "${release_tag}" + sha256sum "${archive_name}" > "${archive_name}.sha256" + echo "archive_name=${archive_name}" >> "$GITHUB_OUTPUT" + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Build Prebuilt gwc Binaries + # A2: ship a prebuilt `gwc` for every supported platform so users skip a from-source + # build. gwc is a pure-Go CLI, so it cross-compiles with CGO disabled; each binary is + # checksummed into a single SHA256SUMS manifest attached to the release. + shell: bash + run: | + mkdir -p dist + release_tag="${{ steps.tag.outputs.release_tag }}" + for target in linux/amd64 linux/arm64 darwin/amd64 darwin/arm64 windows/amd64 windows/arm64; do + os="${target%/*}"; arch="${target#*/}" + out="gwc_${release_tag}_${os}_${arch}" + ext=""; [ "$os" = "windows" ] && ext=".exe" + CGO_ENABLED=0 GOOS="$os" GOARCH="$arch" \ + go build -trimpath -ldflags "-s -w" -o "dist/${out}${ext}" ./tools/gwc + done + ( cd dist && sha256sum gwc_* > SHA256SUMS ) + ls -l dist + + - name: Generate gwc Binary Provenance + uses: actions/attest-build-provenance@v4 + with: + subject-path: dist/gwc_* + + - name: Generate Build Provenance + uses: actions/attest-build-provenance@v4 + with: + subject-path: | + ${{ steps.archive.outputs.archive_name }} + ${{ steps.archive.outputs.archive_name }}.sha256 + + - name: Create Release + uses: softprops/action-gh-release@v3 + with: + tag_name: ${{ steps.tag.outputs.release_tag }} + name: ${{ steps.tag.outputs.release_tag }} + files: | + ${{ steps.archive.outputs.archive_name }} + ${{ steps.archive.outputs.archive_name }}.sha256 + release-assets/sbom.cyclonedx.json + dist/gwc_* + dist/SHA256SUMS + generate_release_notes: true + body: | + Release ${{ steps.tag.outputs.release_tag }} + + Changes in this release: + - Release tag explicitly selected (no auto patch increment on main) + - Passed unit/e2e and release verification gates + - Includes source archive with SHA-256 checksum + - Prebuilt `gwc` binaries for linux/macOS/windows (amd64 + arm64) with SHA256SUMS + - Includes GitHub build provenance attestation (source + binaries) + draft: false + prerelease: false diff --git a/.github/workflows/starter-templates.yml b/.github/workflows/starter-templates.yml new file mode 100644 index 00000000..68b7d298 --- /dev/null +++ b/.github/workflows/starter-templates.yml @@ -0,0 +1,21 @@ +name: Starter Templates + +on: + pull_request: + push: + branches: + - main + +jobs: + starter-templates: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + cache: true + - name: Scaffold, test, and build every starter + run: go test ./tools/gwc -run TestDefaultStarterTemplatesScaffoldTidyTestAndBuild -count=1 + - name: Browser first-pixel smoke for every starter + run: go test -tags playwrightgo ./tools/gwc -run TestDefaultStarterTemplatesMountInHeadlessBrowser -count=1 diff --git a/.github/workflows/supply-chain.yml b/.github/workflows/supply-chain.yml new file mode 100644 index 00000000..86b3f0ac --- /dev/null +++ b/.github/workflows/supply-chain.yml @@ -0,0 +1,88 @@ +name: Supply Chain + +# Runs the framework's own supply-chain gates so the zero-npm posture and the +# known-vulnerability scan actually execute on every change (audit FC2/D5). + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + supply-chain: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + + - name: Build gwc + run: go build -o gwc ./tools/gwc + + - name: Supply-chain audit (zero-npm + dependency budget + checksums) + # Hard gate: a new npm artifact or a dependency-budget breach fails the build. + run: ./gwc supplychain + + - name: Install govulncheck + run: go install golang.org/x/vuln/cmd/govulncheck@latest + + - name: Known-vulnerability scan (reachable advisories) — BLOCKING + # Merge gate: `gwc vuln` blocks the build on any REACHABLE dependency advisory (vulnerable + # code the app actually calls). Reachable stdlib/toolchain advisories are reported but do + # not red the gate by default — they are only fixable by bumping Go, so failing every PR + # on them adds no security value (pass -include-stdlib to gate those too). The full + # govulncheck report is emitted first for the logs, non-fatally. + run: | + $(go env GOPATH)/bin/govulncheck ./... || true + ./gwc vuln + + edge-portability: + # Earn the FC4 "edge-portable" claim: the server stack must actually compile for the + # WASI (wasip1) target, so it runs in edge WASI runtimes, not only on a conventional + # server. A hard gate — a regression that pulls a non-wasip1-clean dependency into the + # server packages fails here. + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + - name: Build server stack for WASI (wasip1) + env: + GOOS: wasip1 + GOARCH: wasm + run: go build ./serverfn/ ./wholestack/ ./localfirst/ ./agentui/ ./query/ ./validate/ ./timetravel/ + + codegen-staleness: + # Generated code must not drift from its source: regenerate and fail if anything changed + # (audit FA4). A typed-routes example exercises `gwc routes gen` against a real package. + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + - name: Setup Go + uses: actions/setup-go@v6 + with: + go-version: "1.26.x" + - name: Build gwc + run: go build -o gwc ./tools/gwc + - name: Routes codegen up to date + run: ./gwc routes check -pkg examples/public/typed-routes-demo + - name: CSS token codegen up to date + run: ./gwc css check -theme examples/public/typed-css-tokens-demo/theme.json -pkg examples/public/typed-css-tokens-demo diff --git a/.gitignore b/.gitignore index c537eb43..aa371277 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,145 @@ +# OS-specific files .DS_Store -static/bin/main.wasm +Thumbs.db +*.swp +*.swo +*~ + +# Compiled binaries +*.exe +*.exe~ +*.dll +*.so +*.dylib +*.wasm + +# Test binaries +*.test +*.out + +# Build artifacts +/bin/** +!/bin/README.md +/dist/ +/build/ +/.pages/ +/.pages-validate/ +/client +/backgroundworker +*.hotreload-manifest.json +static/bin/ +go-compiler-wasm +go-source +/public-examples-site +/static-islands +/agent-demo +examples/13-browser-compiler/static/pkg/ +test/benchmark/bin/ + +# Local binaries and coverage outputs +/runtime +/runtime_native +/test_compile.wasm +/coverage*.out +/cov_*.txt +/internal/runtime/cover_run.json + +# Logs +*.log +logs/ +*.log.* +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* + +# IDE and editor files +# Track the shared team config (committed below) but ignore personal files. +.vscode/* +!.vscode/settings.json +!.vscode/extensions.json +!.vscode/launch.json +!.vscode/tasks.json +.idea/ +*.iml +*.sublime-* +.history/ + +# Dependency directories +vendor/ +node_modules/ +.npm-cache/ +examples/static/.npm-cache/ +examples/static/node_modules/ +package-lock.json + +# Go cache and temporary files +.gocache/ +.gomodcache/ +.gotmp/ +go.work +go.work.sum + +# Coverage and test output +*.coverprofile +coverage.html +coverage.out +*.test.log +test-output*.txt +/coverage +/coverage_* +/cover-* +/cover_* +/tmpcov +/tmpcov_* +coverage_current_* +/ui_cov_fix.cov +/virt_cov_fix.cov +/gwcstats*.cov +/.gocache_cov/ +/101-static-islands +/103-virtualized-feed +/*_cov +/*_cov_* +/%TMPDIR%/ +/$p +/$out +/$profile +/$tmp + +# Playwright test artifacts +test/playwright-report/ +test/test-results/ +test/.playwright/ +playwright-report/ +test-results/ + +# Environment and config files (if sensitive) +.env +.env.local +.venv/ +/chat_history.db +/chat_history.db-shm +/chat_history.db-wal +*.key +*.pem + +# Temporary files +temp/ +*.tmp +*.patch +*.txt +!tools/livereload/scripts/livereload-client.txt + +# Diagnostics artifacts +/diagnostics/* +!/diagnostics/*.go +!/diagnostics/*_test.go +!/diagnostics/README.md + +# Legacy merged workspace residue +/tests/ +.gotmp + +# DevTools extension package build output +tools/devtools-extension/dist/ diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..e5199a53 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "third_party/GoGRPCBridge"] + path = third_party/GoGRPCBridge + url = https://github.com/monstercameron/GoGRPCBridge.git diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 00000000..1913b3d7 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,7 @@ +{ + // Recommended extensions for working on GoWebComponents. VS Code surfaces + // these to contributors who open the repo without the Go toolchain wired up. + "recommendations": [ + "golang.go" + ] +} diff --git a/.vscode/launch.json b/.vscode/launch.json index 40baf493..3ecc03c9 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -1,16 +1,29 @@ { - "version": "0.2.0", - "configurations": [ - { - "name": "Launch Go Program", - "type": "go", - "request": "launch", - "mode": "auto", - "program": "${workspaceFolder}", // This is the directory containing your main.go - "cwd": "${workspaceFolder}", // Set the working directory - "output": "debug", // Output file for the compiled program - "showLog": true, // Show log in the debug console - "trace": "verbose" // Enable more detailed logging for troubleshooting - } - ] + // The browser app is wasm and is driven by `gwc dev` (see tasks.json), not a + // dlv launch. These configs debug the NATIVE tooling and tests, which is + // where a debugger is actually useful in this repo. + // + // Note: these run native binaries, so set GOOS/GOARCH back to host values for + // the integrated terminal if you debug native packages while the workspace + // gopls env is pinned to js/wasm. + "version": "0.2.0", + "configurations": [ + { + "name": "Debug gwc tool", + "type": "go", + "request": "launch", + "mode": "debug", + "program": "${workspaceFolder}/tools/gwc", + "args": ["doctor"], + "env": { "GOOS": "", "GOARCH": "" } + }, + { + "name": "Debug current native test", + "type": "go", + "request": "launch", + "mode": "test", + "program": "${fileDirname}", + "env": { "GOOS": "", "GOARCH": "" } + } + ] } diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..657cb0c4 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,41 @@ +{ + // GoWebComponents compiles to WebAssembly. Most of the framework's + // browser-facing code lives in files guarded by `//go:build js && wasm`. + // Without these two env vars gopls analyzes the package for the host OS and + // hides every wasm-tagged file, so the whole browser half of the codebase + // shows phantom "build constraints exclude all Go files" / undefined-symbol + // errors on minute one. Setting GOOS=js/GOARCH=wasm points gopls at the + // wasm build the framework actually ships. + // + // Trade-off: with this set, the NATIVE-only files (SSR, the gwc tool, native + // stubs) are the ones excluded instead. Flip these to your host values + // temporarily when working on native-only packages, or open that package in + // a separate window. + "gopls": { + "build.env": { + "GOOS": "js", + "GOARCH": "wasm" + }, + "ui.diagnostic.analyses": { + "unusedparams": true, + "unusedwrite": true + } + }, + "go.toolsEnvVars": { + "GOOS": "js", + "GOARCH": "wasm" + }, + "go.testEnvVars": { + "GOOS": "js", + "GOARCH": "wasm" + }, + "[go]": { + "editor.formatOnSave": true, + "editor.insertSpaces": false, + "editor.defaultFormatter": "golang.go" + }, + // The framework is developed on Windows; keep go:embed assets and scripts + // from being silently rewritten away from their committed line endings. + "files.eol": "\n", + "files.insertFinalNewline": true +} diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 00000000..5a9ab8ee --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,29 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "gwc dev (counter example)", + "type": "shell", + "command": "go run ./tools/gwc dev -app ./examples/public/counter/main.go", + "problemMatcher": ["$go"], + "isBackground": true, + "presentation": { "reveal": "always", "panel": "dedicated" }, + "detail": "Start the rebuild-on-save dev loop for the counter example." + }, + { + "label": "gwc test (unit + wasm)", + "type": "shell", + "command": "go run ./tools/gwc test -lane unit -lane wasm", + "problemMatcher": ["$go"], + "group": "test", + "detail": "Run the launcher-owned native and wasm test lanes." + }, + { + "label": "gwc doctor", + "type": "shell", + "command": "go run ./tools/gwc doctor", + "problemMatcher": [], + "detail": "Check toolchain and runtime-asset prerequisites." + } + ] +} diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 00000000..f4bf7d53 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,460 @@ +AGENTS.md + +Skills +Skill files live in agents/. +Load a skill before acting on any task that matches its description. + +agents/design.skills frontend UI, landing pages, components, visual design + +Naming +Use verbSubject[Object]. + +Verbs +get set store cache clear render build handle filter format parse apply reset + +Subjects +Use the owning domain: +sidebar composer thread model conv toolbar user canvas + +Rules +- All new functions and variables start with a verb. +- Subject names the domain, not the data type. +- Add Object only when needed. +- Booleans start with is, has, can, or should. +- Every function needs a GoDoc comment. +- First word of each GoDoc comment must be the function name. +- Complex blocks need intent comments, not mechanics comments. + +Examples +renderSidebar +renderSidebarConvRow +renderComposerInputArea +getModelLabel +storeConvList +cacheScrollPosition +handleUserDeleteConv +clearThreadMessages +buildToolbarSelectOption +isStreaming +hasExactCost + +GWC +Run from repo root: +go run ./tools/gwc + +Main commands +doctor bootstrap start examples dev serve build release test verify files import tailwind bench wasm dashboard seed + +Primary docs +docs/REFERENCE_MANUAL/02-gwc-workflows.md +docs/REFERENCE_MANUAL/12-devtools-testing-and-observability.md +docs/REFERENCE_MANUAL/13-assets-deployment-and-pwa.md +docs/REFERENCE_MANUAL/15-design-notes-and-boundaries.md +tools/README.md + +Help +go run ./tools/gwc -h +go run ./tools/gwc -h +go run ./tools/gwc wasm measure -h +go run ./tools/gwc wasm compare -h +go run ./tools/gwc bench -h + +Flags (terse) +doctor: -json -host -port -audit(-policy/-baseline/-suppress/-write-baseline) +test: -lane -app/-main -root -json +build: -app/-main -root -profile -out/-output -json +dev: -app/-main -root -html/-index -wasm/-output -host -port -dry-run -json +serve: -root -host -port -index -wasm-file -wasm-route -fixture-json +release: -app/-main -root -out-dir -compression -post-link-opt -validate-smoke -json +verify: -app/-main -root -skip-tests -audit(-policy/-min-severity/-baseline/-suppress/-write-baseline) -json +examples/start/bootstrap: examples(-host,-port,-export-static-catalog | | -path ; action=start|status|stop|restart) start(-mode,-init-git,-skip-*) bootstrap(-examples,-host,-port) +files/import/tailwind: files(-root,-ext,-exclude-dir,-json) import(-src,-out,-json) tailwind(-root,-input,-output,-manifest,-skip-manifest,-json) +bench/wasm/dashboard/seed: bench(-root,-lane,-bench,-count,-parallel,-out,-reference,-json) wasm(measure|compare|compare-compression|compare-cache|compare-toolchain; use subcommand -h) dashboard(-root,-status-url,-json) seed(-root,-command,-db-path,-json) + +Typical usage +go run ./tools/gwc doctor +go run ./tools/gwc test -lane unit -lane wasm -lane hydration -lane browser +go run ./tools/gwc build -app .\examples\public\counter\main.go -root .\examples\public\counter +go run ./tools/gwc verify -app .\examples\public\counter\main.go -root .\examples\public\counter +go run ./tools/gwc examples +go run ./tools/gwc .\examples\server\ai-chat-wizard\cmd\server start -json +go run ./tools/gwc .\examples\server\ai-chat-wizard\cmd\server restart -json +go run ./tools/gwc examples .\examples\server\ai-chat-wizard\cmd\server status -json +go run ./tools/gwc serve -root .\examples -port 8090 +go run ./tools/gwc release -app .\examples\public\counter\main.go -root .\examples\public\counter + +Todo execution +Do one todo at a time. + +Per todo +1. Pick one unchecked item. +2. Read only needed files. +3. Make the smallest correct change. +4. Run the minimum validation. +5. Update todo status and notes. +6. Write a checkpoint. +7. Wait 10 seconds if supported, else continue. + +Batching +Do not batch unrelated todos. +Combine only if: +- same subsection +- second is required for the first +- diff stays small +- same validation covers both + +Loop +do one todo +validate +checkpoint +wait if supported +continue + +Checkpoint +- completed todo +- files changed +- validation run +- result +- residual risk +- next suggested todo + +Resume +Reopen the todo list, find the next unchecked item, continue from the last checkpoint, do not redo completed work. + +Stop +Stop when no unchecked todos remain. + +Priority +Controlled sequential progress beats throughput. + +Bug fix workflow +1. Reproduce with the smallest reliable command, test, or browser flow. +2. Capture the exact failure. +3. Find root cause before editing. +4. Prefer the smallest root-cause fix. +5. Preserve public behavior unless the bug requires change. +6. Keep useful diagnostics. +7. Validate narrowly first, widen only if needed. + +Implementation rules +- Do not guess when the repo can be inspected. +- Do not hide panics or errors just to pass tests. +- Do not remove useful debug detail without a good reason. +- Do not touch unrelated files or formatting. +- Respect nearby user changes. + +Validation rules +- Prefer focused package tests, targeted Playwright specs, or the smallest reproducible command. +- For browser issues, capture the real console or page error. +- For wasm or cross-compilation, clear stale env vars first. +- Confirm the bug is fixed and diagnostics are clearer. +- Ad hoc binaries from repo root go under ./bin. + +Examples +go test -c -o ./bin/.test +go build -o ./bin/.exe + +Final report +- root cause +- what changed +- validation run +- remaining risk or follow-up + +================================================================ +BUILDING APPS WITH GOWEBCOMPONENTS +================================================================ +Everything below is what an agent needs to author working apps. It is the +programming model; the sections above are the workflow and naming rules. Both +apply at once. + +Module path +github.com/monstercameron/GoWebComponents +Import public packages by that path, e.g. + "github.com/monstercameron/GoWebComponents/ui" + "github.com/monstercameron/GoWebComponents/html" + . "github.com/monstercameron/GoWebComponents/html/shorthand" // dot-import sugar + +Mental model +React-style components + hooks on a fiber runtime, written in Go, compiled to +js/wasm. A component is a Go function that returns a `ui.Node`. Hooks give it +local state, effects, and async. You build the DOM with typed `html` builders +(or the `html/shorthand` dot-import sugar) and mount with `ui.Render`. Crash +containment is on by default - a panic in one component is isolated, not a +white screen. + +A component +- A component is `func(props P) ui.Node` (props may be omitted: `func() ui.Node`). +- Call hooks ONLY at the top level of the component body - never in a + conditional, loop, goroutine, or nested closure. (`gwc lint` has a + `gwc-hooks` pass that enforces this; dev/test builds also panic on a + cross-goroutine hook call.) +- Wrap it with `ui.CreateElement(Component)` or + `ui.CreateElement(Component, props)` to get a mountable node. +- Return built nodes; do not touch the DOM directly. + +Minimal app (entry file MUST be js/wasm - see build constraint) + + //go:build js && wasm + + package main + + import ( + . "github.com/monstercameron/GoWebComponents/html/shorthand" + "github.com/monstercameron/GoWebComponents/ui" + ) + + // App renders the root component. + func App() ui.Node { + parseCount := ui.UseState(0) + parseInc := ui.UseEvent(func() { + parseCount.Update(func(parsePrev int) int { return parsePrev + 1 }) + }) + return Div(Class("p-4"), + Div(Class("text-2xl"), Textf("count: %d", parseCount.Get())), + Button(OnClick(parseInc), Class("mt-2 rounded bg-cyan-500 px-3 py-1"), Text("+")), + ) + } + + func main() { + ui.Render(ui.CreateElement(App), "#app") + select {} // keep the wasm runtime alive + } + +The canonical, fuller reference is examples/public/counter/main.go (it uses the +example boot harness `exampleboot.RenderExampleRoot` instead of bare +`ui.Render`; for a standalone app use `ui.Render(node, "#app")` plus `select {}`). + +Build constraint (non-negotiable) +- The app entry (`package main` with `main()`) and any file using browser APIs + is `//go:build js && wasm`. Build with GOOS=js GOARCH=wasm (gwc does this). +- gopls hides js/wasm files unless GOOS=js/GOARCH=wasm is set; the committed + `.vscode/settings.json` does this. Clear stale GOOS/GOARCH before native work. + +wasm / native split (how the framework stays buildable on both targets) +- Browser-only code lives in `*_wasm.go` (`//go:build js && wasm`). +- A matching `*_native.go` stub (`//go:build !js || !wasm`) provides the same + exported signatures and returns an "unavailable" result so the package still + compiles, vets, and unit-tests on the host. Native tests assert the + unavailability via `interop.IsCode(err, interop.CodeUnavailable)`. +- When you add a browser capability, add BOTH files. Pure-Go logic (parsing, + serialization, formatting) goes in a tag-free file so it is unit-testable on + the host and identical on both targets. + +Building the DOM +- Typed builders in `html`: `Div`, `Span`, `Button`, `H1..H6`, `P`, `Ul`, `Li`, + `Input`, `Form`, `Img`, ... plus `Text(s)`, `Textf(format, ...)`, `Fragment()`. +- Sugar via `. "html/shorthand"` dot-import: `Class(...)`, `ClassNames(...)` + (compose Tailwind class strings), `When(cond, class)`, `IfElse(cond, a, b)`, + `OnClick(handler)`, `Props{...}`. The counter example shows the idiom. +- Props are attributes/handlers; children are trailing varargs. +- Styling is Tailwind; `gwc tailwind` builds the shared CSS + class manifest. + +Hooks (package ui) - the surface you will use most +State / lifecycle: + UseState[T](initial) State[T] // .Get() .Set(v) .Update(fn) + UseReducer[S,A](reducer, initial) // Redux-style + UseRef[T](initial) Ref[T] // mutable box, no re-render + UseEffect(func() func(), deps...) // returns a cleanup func; deps gate it + UseMemo[T](compute, deps...) T + UseCallback[T](fn, deps...) T + UseEvent(fn) Handler // stable event handler (use for OnClick) + UseContext[T](*Context[T]) T + UseId() string // stable unique id (labels/aria) + UsePrevious[T](v) Previous[T] +Async / data: + UseTask[T](run func(ctx) (T,error)) Task[T] + UseChannel[T](<-chan T) Channel[T] + UseLazyNode(loader, deps...) // code-split / defer a subtree + UseWorkerTask[...] // offload to a web worker +Perf / scheduling: + UseTransition(), UseDeferredValue[T], UseDebounced[T], UseThrottled[T] +Accessibility: + UseAnnouncer(), UseFocusTrap(opts), UseFocusManager(), + UseCompositeNavigation(items, opts), UseOverlayStack(opts) +Preferences / animation: + UsePrefersReducedMotion() bool, UsePrefersColorScheme() ColorScheme, + UseSpring(target, anim.SpringConfig) float64 +Persistence: + UsePersistedState[T](key, initial, area) // localStorage/sessionStorage write-through + cross-tab + +Beyond local state (other packages) +- state : `UseAtom[T](id, initial) Atom[T]` - app-wide shared reactive state + (fan-out to every reader). Atoms are app-global by id. +- events : typed in-app pub/sub. `events.UseTopic[T](topic, handler, opts...)`, + or non-hook `events.Subscribe[T]` / `events.Publish[T]`. Exactly-once + fan-out, lifecycle-tied unsubscribe. +- router : `router.NewHashRouter()` / `NewHistoryRouter()`, + `router.RegisterRoute(path, component)`, `router.Navigate(path)`, + `router.Current()`. +- fetch : data hooks - `UseQuery`/`UseInfiniteQuery`/`LoadQuery`, cache with + tags (`InvalidateQueryTag`), `UseWebSocket`/`UseEventSource`, + `MutationQueue` (offline replay), and resilience (`RetryPolicy`, + `CircuitBreaker`, `ExecuteWithPolicy[T]`). Cache keys are app-global; + scope with `fetch.ScopeCacheKey(...)`. +- flags : feature flags + weighted experiments; `flags.RemoteProvider` for + remote config + kill switches. +- i18n : `FormatNumber`/`FormatDate`/`FormatRelativeTime`/`FormatList`, plural + rules, `T(namespace, key)` messages. Browser ICU bridge via interop. +- interop: browser APIs from Go (cookies, crypto.subtle, Intl, media queries, + rAF, document events, workers) - always a `_wasm.go` + `_native.go` + pair returning `CodeUnavailable` on the host. +- pwa : service worker registration, install observation, offline diagnostics. +- anim : pure-Go `Spring` (presets GentleSpring/WobblySpring/StiffSpring), + easings, FLIP. Drive UI with `ui.UseSpring`. +- sanitize: `Sanitize(html, ...Policy)` for untrusted HTML (there is no raw + innerHTML sink in the render path by design - never reintroduce one). + +SSR / hydration (server-side rendering) +- `ui.RenderToString(node) (string, error)` - render a tree to HTML on the host + (no browser). This is also the headless oracle for tests. +- `ui.RenderToStream` / `RenderToStreamObserved` - streaming SSR; emits a shell + before async `AsyncBoundary` content, flushes replacements as they resolve. +- Hydration attaches the wasm runtime to server HTML; bootstrap sidecars carry + versioned payloads. Static islands hydrate selectively. +- Async data: wrap suspending work in `AsyncBoundary` with `ui.SuspendUntil` / + `ui.Await`; SSR renders the fallback, the client retries on resolve. + +Run / build / verify an app (from repo root) + go run ./tools/gwc dev -app .\path\to\main.go # build+serve+livereload + go run ./tools/gwc build -app .\path\to\main.go -root .\path + go run ./tools/gwc verify -app .\path\to\main.go -root .\path # tests + CI wasm build + go run ./tools/gwc release -app .\path\to\main.go -root .\path + go run ./tools/gwc test -lane unit -lane wasm -lane hydration -lane browser + go run ./tools/gwc lint # golangci-lint + gwc-hooks +Browser tests live under test/playwrightgo/ (build tag `playwrightgo`); run with + go test -tags playwrightgo ./test/playwrightgo/... + +Hard rules (these cause real bugs if broken) +- Hooks at the top level of the component only - never conditional/loop/goroutine/closure. +- All local variables are `parse`-prefixed (see Conventions); exported names are + ordinary Go; functions are `verbSubject`; GoDoc first word = the symbol name. +- Add the `_native.go` stub whenever you add a `_wasm.go` browser file. +- Do not introduce a raw-HTML sink (innerHTML/outerHTML) on the render path; + use text/attribute APIs or the `sanitize` package. A guard test enforces this. +- Do not hide panics to pass tests; crash containment surfaces them deliberately. +- Keep handlers stable with `UseEvent`; do not allocate a new closure as a DOM + handler on every render where it matters. + +More docs +- docs/REFERENCE_MANUAL/ (workflows, devtools/testing, assets/PWA, boundaries) +- docs/CONVENTIONS.md (the naming/`parse`-prefix contract in full) +- docs/capabilities + docs/errorcodes (capability matrix + error codes) +- README.md (overview + quick start) +- examples/public/ (runnable single-file apps; counter is the canonical one) + +================================================================ +THE AGENTIC SDLC WITH GWC +================================================================ +`gwc` (go run ./tools/gwc ) is the toolchain. Treat building an app as +a loop, not a line: orient -> plan -> scaffold -> implement -> build -> verify +-> review -> diagnose -> release -> observe -> back to plan. Below, each phase +maps to the command to reach for. "Today" = available now. "Planned" = speced +in todos.md (Agentic gwc section), NOT yet built - do not assume it exists; use +the Today column until it lands. + +Phase Today (use now) Planned (roadmap) +orient inspect (routes/deps/ownership), richer semantic ranking + doctor, model, search, explain, + README + docs/ +plan inspect (dependency report), richer multi-symbol impact + inspect --impact +scaffold start (TUI), init, import, starter expansion coverage + scaffold --no-input --json +implement edit files directly (Go), mutate, broader codemod recipes + click/type/press/hover/scroll (drive + the running app over CDP) +build build, wasm, release (build --json envelope) +verify test (-lane unit/race/wasm/ single acceptance gate + hydration/browser/agent/ + agent-browser/release), verify, + verify --agent, render, probe, bench, + lint, screenshot + screenshot-diff + (visual regression) +review lint / review, doctor -audit, richer fixes-as-data + check --json +diagnose doctor, dev (livereload + doctor- deeper hydration/commit + on-failure), dev --agent, observe trace coverage + --agent, sessions/snapshot/query, + snapshot-diff, test output, browser + (headed window), screenshot, console, + network, dom, eval (live CDP proxy) +migrate migrate (-apply safe rewrites), mutate arbitrary-safe ops +release release, deploy, prerender/export (canary rollout) +observe observe, observe --agent, queryable RUM/crash/replay + logging/diagnostics packages, + devtools panels + +Today's commands (one line each) + doctor check toolchains, runtime assets, project signals, optional audit + inspect route / dependency / ownership / file-type reports + model emit a static component manifest for agent planning + search search exported APIs by intent using the static manifest + explain resolve diagnostic error codes and framework capabilities + start scaffold TUI (presets); init = non-interactive project init + import convert a static HTML/JSX file into an inspectable GWC project + scaffold generate components, hooks, examples, or starter apps without prompts + mutate apply safe AST-backed source mutations with dry-run and JSON diff output + dev build app -> serve -> livereload (auto-runs doctor on failure) + build build a js/wasm app with an explicit profile + wasm wasm build experiments: measure / compare / compare-compression / ... + test run lanes: unit, race, wasm, hydration, browser, agent, agent-browser, release + verify app-local Go tests + a CI-profile wasm build; --agent emits NDJSON + render render a component through the headless SSR oracle + probe run a browser-oracle probe for a URL or example target + check run agent-shaped diagnostics across tests and source conventions + bench discover + run native/wasm benchmarks, compare with benchstat + lint golangci-lint + built-in gwc-hooks rules (review is an alias) + migrate compatibility findings + safe parser-backed rewrites (-apply) + prerender static export (route HTML + wasm + manifest); export is an alias + release package a js/wasm release with manifest + compressed sidecars + mcp serve JSON-capable gwc commands as local stdio MCP tools + sessions list live local agent-bridge sessions + snapshot read a redacted live agent-bridge runtime snapshot + query find live agent-bridge nodes by semantic selector + set-atom set a live agent-bridge atom value + emit invoke a live agent-bridge node event handler by ref + publish publish a live agent-bridge topic event + navigate drive live agent-bridge router navigation + snapshot-diff compare two agent-bridge snapshots by stable ref + browser open a headed (visible) Chromium window on a dev URL (-tags playwrightgo) + screenshot capture a PNG of a running app (full page / selector / -cdp attach) + screenshot-diff diff two PNGs for visual regression (default build, no browser) + click/type/press/hover/scroll real DOM input over CDP (-tags playwrightgo) + console capture browser console messages + uncaught JS errors over CDP + network capture browser requests/responses/failures over CDP + dom read the real rendered DOM (text/HTML/attrs) for a selector over CDP + eval evaluate read-oriented JS in the live page over CDP (dual-use) + deploy package validated release artifacts through deploy adapters + tailwind build shared Tailwind CSS + class manifest + seed provision local dev identities + fixture data + examples serve the catalog or manage example servers (start/status/stop/restart) + dashboard monitor livereload clients + AI provider config + env print launcher-relevant environment variables +Every command supports `-h`; many support `-json` (see the Flags section above). +Run from repo root: `go run ./tools/gwc -h`. + +Recommended loop for building an app (with today's tools) +1. orient - `inspect` the target area; read the nearest example + docs. Do not + guess when the repo can be inspected. +2. plan - scope the change; check the dependency report for blast radius. +3. change - make the smallest correct edit (one todo at a time; see the + workflow rules above). Add the `_native.go` stub with any + `_wasm.go`. +4. build - `gwc build -app ... -root ...` (clear stale GOOS/GOARCH first). +5. verify - run the SMALLEST lane that proves it: `gwc verify` for tests+CI + build, or `gwc test -lane wasm`/`-lane browser` for the relevant + surface. For browser behavior, `go test -tags playwrightgo + ./test/playwrightgo/...`. Capture the real console/page error on + failure - never a paraphrase. +6. review - `gwc lint` (conventions + gwc-hooks). Fix, re-run. +7. checkpoint - record completed todo, files changed, validation run, result, + residual risk, next todo. Then continue. +Claim done only with evidence (a passing lane / clean lint / a rendered +oracle), never on assumption. A green `verify` + clean `lint` is the current +definition-of-done; use `verify --agent` when the loop needs NDJSON events and +trace summaries. + +MCP +`gwc mcp` exposes JSON-capable commands as local stdio MCP tools so an agent can +call them natively instead of shelling out. It is a local developer surface; a +shipped HTTP+auth MCP service remains future productization work. diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 00000000..8b41f547 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,2983 @@ +# Changelog + +## v4.0.0 - 2026-06-28 + +### Added + +- **`agentui.Registry.Catalog` — allow-list introspection for MCP tools (V4, F4).** Exposes + the component allow-list as sorted, JSON-serializable `ComponentInfo` (name + permitted + props) so an agent — or an MCP tool serving the registry over the existing `agentbridge` — + learns up front exactly what it may emit, turning the allow-list into guidance rather than + an after-the-fact rejection. +- **`hotreload.SchemaChanged` — state-schema-change detection (V4, C1).** Fingerprints a + state snapshot's shape (keys + value types) so a state-preserving hot reload can show a + visible "state reset" when the shape changed instead of silently restoring a persisted + snapshot into a mismatched type — the ghost-bug fix the plan calls out. +- **`ui/erroroverlay.ErrorOverlay` — in-page Elm-grade error overlay (V4, FB4).** A dogfooded + component that renders a development error as a dismissible, accessible modal (title, + message, actionable "Try: …" hint, optional stack), so failures are legible in the page, + not just the console. `FromError` builds props from a Go error. +- **`gwc buildreport` — "what rebuilt & why" (V4, C2 platform-honest).** Derives a per-build + report from `go build -debug-actiongraph`: which packages were rebuilt (the `NeedBuild` + cache-miss signal) vs served from cache, ranked by compile time, with the warm/cold wall + time. The achievable platform-honest C2 surface; the true 10-rung (incremental wasm + linking) is an upstream Go ask the plan tracks as non-blocking. +- **VS Code extension surfacing `gwc lint` diagnostics (V4, tooling).** A minimal real + extension (`tools/vscode-gwc`) that runs `gwc lint --json` on save and shows issues inline + via a `DiagnosticCollection`. Its mapping core (severity, 1-based→0-based positions, source + tagging) is host-independent and unit-tested under plain Node; it consumes the stable CLI + contract owned in Go, so the editor integration stays a thin language-agnostic consumer. +- **Edge/WASI portability of the server stack (V4, FC4).** The server-side V4 packages — + `serverfn`, `wholestack`, `localfirst`, `agentui`, `query`, `validate`, `timetravel` — are + written platform-clean and verified to compile to `GOOS=wasip1` (WASI), so the whole-stack + handler and the sync/server-function/generative-UI engines run in edge WASI runtimes, not + only on a conventional server. "Ride the wasm platform leap" — the same Go, server-side at + the edge. +- **`wholestack` — one-binary, whole-stack, edge-portable deployment (V4, FC5).** `Handler` + composes a single `http.Handler` that serves the embedded wasm bundle (index + `.wasm` + + `wasm_exec.js`) AND the app's `//gwc:server` functions, with SPA fallback so client-routed + paths deep-link to the shell. One `go build` is the entire app — no Node, no separate + static host, no reverse proxy — and it runs anywhere `net/http` runs, including edge + runtimes. `ListenAndServe` is the one-line entry point. Verified end-to-end: the app shell, + a static asset, and a server function all served from one handler; SPA fallback; opt-out. +- **In-app devtools/collaboration panels — dogfooded as GWC components (V4).** The plan's + "panels" and "galleries" are built as testable framework components (the framework + rendering its own tooling), each verified headlessly through the real reconciler + mock + DOM: `timetravel/devpanel.Panel` (time-travel scrubber timeline + step controls, C4/FB6), + `workbench/gallery.Gallery` (component gallery over the same stories `RunStories` tests, + FB5), `query/devtools.CachePanel` (cache observability table over the new `Cache.Inspect`, + D2), and `localfirst/facepile.Facepile` (presence "who's here" surface, FC6). +- **`query.MutateAsync` — fire-and-forget optimistic actions (V4, FB2).** Applies the + optimistic value immediately and reconciles in the background (commit on success, rollback + on error, `onSettled` callback) — the async mutation that makes Next/Remix-style server + Actions a one-liner. Verified end-to-end as an optimistic action over a real `//gwc:server` + function (optimistic value on screen immediately; server's authoritative result committed + on settle). +- **`timetravel` — snapshot step-back replay engine (V4, C4/FB6).** The pure engine behind + time-travel devtools (C4) and undo/redo (FB6): a bounded, navigable `History[T]` of + immutable snapshots with `Record`/`Undo`/`Redo`/`ScrubTo`, standard redo-branch + truncation, and ring eviction. Owns no clock/DOM/runtime; the devtools panel is a thin + view over `Labels()`/`ScrubTo`. +- **`ui.UseInspect` — Svelte-style `$inspect` (V4, FB7).** Logs a labeled value's initial + state and every subsequent change (`old -> new`, by structural equality) through a + swappable sink (`SetInspectSink` → devtools, a test buffer, or silenced in production). +- **`shorthand` named slots/snippets (V4, FB7).** Explicit, typed named slots (Vue named + slots / React render-children-by-name): `Slot`/`NewSlots` (last-wins) + `Has`/`Render`/ + `Or` (overridable default content). +- **Public-API baseline tests for V4 packages (V4).** `internal/apidump` extracts a + package's exported surface (types with their shape, funcs, methods, consts, vars) as + sorted signature lines and checks it against a committed golden, so any change to the + public API of `serverfn`/`query`/`localfirst`/`agentui`/`validate`/`anim` fails a test + with a diff and can only land by regenerating the golden (`UPDATE_API_BASELINE=1`) with + intent. This is the concrete "graduated to Stable, API-baseline pinned" mechanism. +- **`agentui` — agent-native generative-UI runtime (V4, FC3).** A typed renderable schema + an agent emits (server-side behind a `//gwc:server` function), validated against a + component allow-list, then rendered to real UI. The safety property is structural: a + `Node` carries no code, no event handlers, no raw HTML — only an allow-listed component + `Type`, string `Props` the component permits, plain (escaped) `Text`, and `Children`. An + agent composes allow-listed components but can never inject behavior or markup — + the "allow-listed components, not raw code" guarantee, expressed natively by GWC's typed + component model. `Registry.Validate` recursively rejects any non-allow-listed type or + disallowed prop; `Render`/`RenderJSON` gate on validation. `DefaultRegistry` ships safe + presentational components. Verified end-to-end: agent JSON → validate → render → mounted + DOM shows the content. Hardened against untrusted-input DoS with safe-by-default size + bounds (`Limits`/`DefaultLimits`: max depth 32, max 10k nodes; `ValidateWithLimits` to + tune). +- **`localfirst.PresenceSet` — collaboration presence/awareness (V4, FC6).** Real-time + collaboration is the converging document store (FC1) plus ephemeral presence; presence is + the only new piece, so FC6 comes nearly for free. `PresenceSet` tracks live peers (cursor/ + name/status as an opaque payload) with heartbeat expiry and no wall clock — the app + advances time via `Tick`, so a crashed tab leaves the session deterministically. Distinct + from synced `Record`s by design: "who is here now" has no history. +- **`localfirst` — built-in local-first sync engine (V4, FC1).** The convergence engine + behind local-first sync (Zero/Electric/TanStack DB), pure Go on both sides: a + last-write-wins register per key (LWW-Register CRDT) with a logical `Clock` (higher + counter wins, replica id breaks ties → every replica resolves a conflict identically). A + `Replica` gives optimistic local writes, a durable offline pending log, and a `Merge` + that converges toward authoritative records while acknowledging confirmed writes and + preserving Lamport monotonicity; an `Authority` is the server-side store. `Mutation`/ + `Record` are JSON-serializable so they ride the `//gwc:server` transport unchanged. + Marquee guarantee verified: two replicas edit the same key offline, reconnect, and every + replica + the authority converge to the one value — proven both in-process and + **end-to-end over the real `serverfn` HTTP transport** (FC1 × FB1). The offline queue is + durable: `Replica.Export` / `RestoreReplica` round-trip the full replica (records + + pending log + counter) through JSON, so unsynced writes survive a page reload and still + converge on reconnect (E3 — offline replay is the same engine). +- **`gwc add` — headless component registry (V4).** The shadcn "own the code" model: + `gwc add ` copies an a11y-correct, self-contained component into your repo (with + your package name and a provenance header) — you own and restyle it, no runtime + dependency. Catalog: `disclosure` (WAI-ARIA disclosure) and `tabs` (WAI-ARIA + tablist/tabpanel with a roving tab stop), each verified native + wasm. Templates live as + a real compiled package, so the catalog can never ship a component that doesn't build + (FA3). +- **`gwc vuln` — known-vulnerability reachability scan (V4).** Runs `govulncheck -json` + and classifies each finding as REACHABLE (a call trace names a vulnerable function) or + imported-only. Reachable vulnerabilities fail the build; imported-only pass unless + `-strict`. Complements `gwc supplychain` on the security dimension (D5). Verified against + the live Go vuln database. +- **`//gwc:server` server functions — the FB1 keystone (V4).** A server function is a + plain, type-safe `func(context.Context, Req) (Resp, error)` marked `//gwc:server` that + runs only on the server. The new `serverfn` runtime exposes `Handle` (register it as a + JSON HTTP endpoint) and `Call` (invoke it, returning the typed response or a typed + `*ServerError`); both use `net/http`+`encoding/json` with no build tags, so the server + uses real sockets and the browser uses Fetch-backed `net/http` — the same code path, + fully testable with `httptest`. `gwc server gen` scans for `//gwc:server` functions, + enforces the contract, and generates `serverfn_gen_client.go` (browser stubs calling + `serverfn.Call`) + `serverfn_gen_server.go` (`RegisterServerFunctions(mux)` wiring each + via `serverfn.Handle`). One Go signature, called from the browser with full compile-time + type safety and no hand-written fetch/JSON glue — verified end-to-end: native server + + wasm client both compile, and a function round-trips over HTTP through the generated + registration. (Contract: shared Req/Resp types in a build-tag-free file, the server + function in a `//go:build !js || !wasm` file; the codegen rejects an unconstrained file + to prevent client/server name collisions. `gwc server check` is the CI staleness gate.) +- **`router.DecodeQuery` / `EncodeQuery` — typed, validated search params (V4).** Decode + URL query strings into a typed struct via `query:"name"` tags + (string/bool/int/uint/float/[]string), then validate it with the `validate` package + using `validate:"..."` tags on the same struct — one typed read instead of scattered + `q.Get` + `strconv` + bounds checks. Malformed values error with the offending param; + validation failures return the `validate.Result`. `EncodeQuery` is the inverse for + building links (zero fields omitted). Meshes typed routes (B7), compile-safe data (B3), + and shared validation (B8). +- **`validate` now supports `omitempty` (V4).** An optional field whose value is the zero + value skips its remaining rules, and is validated normally when present. +- **`anim` keyed-list FLIP + enter/exit transitions (V4).** The FA5 orchestration layer + over the existing FLIP/spring math: `DiffKeyedRects` classifies a keyed layout change + into entering/exiting/moving items and computes each survivor's FLIP invert transform + (`MovedKeys()` filters to items that actually moved); `Transition` is a pure, clock-free + enter/exit state machine (`Entering→Entered`, `BeginExit→Exiting→Exited`) with + `Progress`/`IsAnimating`/`IsRemovable`; `StaggerDelay` gives per-index cascade timing. + Owns no DOM and no clock — fully deterministic and unit-testable. Honors + `prefers-reduced-motion` via an explicit `MotionPreference` (`Animates()`, + `EffectiveDuration()`, `NewTransitionPref()`): under reduced motion, transitions snap + and FLIP moves are skipped (FA5 × D4). +- **`gwc i18n gen` — typed, compile-checked message accessors (V4).** Reads a + base-locale bundle (`{"namespace":{"key":"text {param}"}}`) and generates + `i18n_keys_gen.go`: one typed accessor per message wrapping `i18n.Runtime.T`, taking a + string argument for each `{param}`. A typo in a namespace, key, or interpolation + parameter — or a forgotten/extra param — becomes a compile error rather than a silent + runtime miss. `gwc i18n check` is the CI staleness gate (regen + diff). The codegen + pair to `gwc routes gen`, closing the last stringly-typed surface (F6/B3). +- **`query` package — stable query/data layer (V4).** GoWebComponents' Go-native + answer to TanStack Query / SWR: a keyed, concurrency-safe cache with request + de-duplication (N concurrent `Fetch`es for one key coalesce into a single fetcher + call), stale-while-revalidate (`SWR` returns stale data synchronously and refreshes + in the background), one-call optimistic mutations with automatic rollback on error + (`Mutate`), and invalidate-by-key / by-prefix. Kept deliberately **explicit** — the + key and fetcher are passed at every call site, nothing is auto-tracked — and **pure + Go**, so the whole layer compiles to wasm and native and is fully unit-testable + (`WithClock` injects deterministic time). Implements FA2 / graduates B6 to Stable. + Consumed in components via the new `ui.UseQuery` / `ui.UseMutation` hooks + (`query.Snapshot[T]` for the render path), covered by two wasm e2e tests through the + real render path — cached data painting to the DOM, and the full optimistic-mutation + loop (commit updates the DOM; failure rolls it back). +- **`ui.Form.ValidateStruct()` — turnkey shared validation (V4).** Validates a form's + value against its `validate:"..."` struct tags with no hand-written client + validator, so the same struct validates client (wasm) and server (native) from one + source and the two cannot drift. Capstone of B8. +- **`state.Signal[T]` / `state.NewSignal` / `state.NewComputed` — fine-grained + reactivity as a first-class primitive (V4).** A terse, ergonomic handle over the + shared atom registry that updates exactly the DOM nodes bound to it + (`signal.Text(...)`) without re-rendering the owning component. Needs no + caller-managed id (one is minted; `NewKeyedSignal` shares an explicit id), and is + created outside the hook lifecycle so it can live in a package var, event handler, + or goroutine. `NewComputed` derives from **explicitly declared** sources — GWC + keeps reactivity predictable and auditable rather than discovering dependencies + through a hidden runtime graph. Signals compose with `ui.ReactiveRegion` and + `state.UseSelector` (same source contract as atoms/derived). Covered by native + unit tests + wasm fine-grained-update tests. +- **`gwc routes gen` — typed, compile-checked route links (V4).** Scans a package + for `router.MustDefineRoute("/users/:id")` contracts and generates `routes_gen.go` + with typed `Link*` constructors (`LinkUser(id string) string`), so a missing or + misnamed path parameter becomes a **compile error** instead of a runtime one — + closing the last stringly-typed gap that the runtime `RouteContract` can't. + `gwc routes check` is the CI staleness gate. Output is `go/format`-clean. +- **`validate` package — dependency-free shared struct-tag validation (V4).** One + Go struct with `validate:"required,email,min=3,oneof=..."` tags validates + **identically on the server and the client** — `validate.Struct(v)` runs in an + HTTP handler and, because it uses only reflect/regexp/strconv (no syscall/net/file), + in the browser via wasm in `ui.UseForm`, so client/server validation can never + drift. `Result.Fields()` is `map[string]string` (the `ui.FieldErrors` shape) and + `Result` implements `error` for handlers. Rules: required/min/max/len/email/url/ + oneof/eq/ne/gt/gte/lt/lte/alpha/alphanum/numeric, with nested-struct dotted paths. +- **`gwc llms` — AI-native docs generation (V4).** Generates `llms.txt` (the + llms.txt-standard index: project header + a linked, summarized table of every + reference-manual chapter) and `llms-full.txt` (all chapters concatenated for + full-context ingestion) from `docs/REFERENCE_MANUAL`. Deterministic output with a + `-check` CI staleness gate (regenerate + diff). The first step toward "the + framework your AI assistant gets right the first time." +- **`gwc supplychain` — supply-chain / zero-npm audit command (V4).** Proves a + project has **no npm dependency surface** (scans for `package.json`/lockfiles/ + `node_modules`, excluding research/examples/vendor/testdata), counts direct vs. + transitive Go modules, confirms `go.sum` checksums are present, and enforces an + optional `-budget N` on direct external dependencies. Locally-`replace`d modules + are excluded from the remote count. Emits the `gwc.agentic.v1` JSON envelope or a + human summary; non-zero exit on failure. The framework itself audits clean + (0 npm, checksum-verified). Adds **zero** dependencies — parses go.mod/go.sum by hand. +- **`html.BindTo` / `html.BindFunc` (+ shorthand re-exports) — two-way binding for + any handle.** Complements `html.Bind` (which binds a `ui.State[string]`) with a + structural `html.Binding` interface (`Get() string` / `Set(string)`), so the new + `state.Signal[string]`, atom handles, or an explicit getter/setter all bind a + controlled input in one option — no `value=`+`oninput=parse` pair. +- **`ui.Run(selector, component, props...)` — a one-line browser entrypoint.** It + wraps `ui.CreateElement` + `ui.Render` + the keep-alive block so a typical + `main()` is a single call (`ui.Run("#app", renderApp)`) instead of the + `Render(CreateElement(fn, nil), "#app")` + `utils.WaitForever()` pair. The + explicit primitives are unchanged and remain the right choice for SSR, native, + tests, or when `main` must do work after mounting. On the native/SSR slice + `ui.Run` panics with the unified unsupported-on-server contract, mirroring + `ui.Render`. README and getting-started examples now lead with `ui.Run`. +- **`interop.KeepAlive()` — the shared keep-alive primitive.** `utils.WaitForever` + and `ui.Run` both delegate to it. It lives in the leaf `interop` package so + `ui` can reuse it without the `ui → utils → hotreload → state → ui` import + cycle. `utils.WaitForever` is unchanged for callers (same name, same behavior). + +## v3.5.4 - 2026-06-25 + +### Fixed + +- **Effects were dropped when a component used render-phase updates (regression in + v3.5.3).** The render-phase convergence loop cleared the fiber's per-iteration + effect list before each re-run; combined with the deps-equality check (a + stable-deps effect does not re-register when its deps are unchanged), the effect + ended up registered in no iteration and never ran. The loop no longer clears the + effect list — effects accumulate across convergence iterations and are then + de-duplicated by cleanup-index (keeping the last, i.e. the final render's effect + per slot). Each effect now runs exactly once with the converged state, for both + stable and changing deps, and multiple effects run once each in declaration + order. Covered by `TestRenderPhaseEffectRunsOnceStableDeps` / + `...ChangingDeps` / `TestRenderPhaseMultipleEffectsEachOnce`. + +## v3.5.3 - 2026-06-25 + +### Fixed + +- **Render-phase state updates left the DOM inconsistent with the render.** When a + component updated its own state during render (`if x { setState(...) }` — the + derived-state-during-render pattern), the setter stored the new value and + scheduled a commit, but the component was never re-run, so the committed DOM + showed a value the component had not actually rendered (e.g. it rendered `0` but + the DOM showed `1`, and it never converged). `renderFunctionComponent` now + detects a render-phase update (the setter's owner is the fiber actively + rendering, tracked by a new `activeRenderFiber` flag — distinct from the ambient + current fiber so it never trips on the SSR path or hook unit tests) and re-runs + the component to convergence, bounded at 25 iterations with a diagnostic to + guard against an unconditional-setState infinite loop. Matches React's + "keeps restarting until there are no more new updates." Covered by + `TestRenderPhaseUpdateConverges` / `TestRenderPhaseDerivedStateOneStep` / + `TestRenderPhaseUnconditionalDoesNotHang`. + +## v3.5.2 - 2026-06-25 + +### Fixed + +- **`defaultValue` / `defaultChecked` rendered as inert attributes in SSR.** An + uncontrolled form field set via `defaultValue` (or `defaultChecked`) serialized + the prop literally — `` — which the browser ignores, so + the field rendered empty/unchecked server-side. The SSR serializer now maps + `defaultValue` → the element's controlled value and `defaultChecked` → `checked` + (only when the controlled prop is not already set, so an explicit `value` wins), + in both the buffered and streaming renderers. Because the mapping happens before + the controlled-value logic, it flows through every form element: `` gets + a `value` attribute, ``, so a + controlled textarea rendered blank server-side and mismatched on hydration (the + client path sets `.value` as a DOM property, which masked the bug outside SSR). + The serializer now renders a textarea's string `value` as escaped text content + (``), matching React's `ReactDOMServerIntegrationTextarea` + behavior; other attributes are preserved and an explicit child is used when no + `value` is set. Fixed in both the buffered and streaming SSR renderers. Found + while porting React's controlled-input SSR tests. Covered by + `TestSSRTextareaValueRendersAsContent`. (Note: `` by value/label), `gwc upload` (file inputs), `gwc drag` (drag one + selector onto another) — finishing the set begun with click/type/press/hover/ + scroll. **Network write side:** `gwc mock` intercepts a `-route` glob and + stubs (`-status`/`-body`) or `-abort`s it to exercise error paths. All `-cdp`/ + `-url`, auto-generated MCP tools, covered by `playwrightgo` tests against real + Chromium. Also fixed the `dev_loop_browser_e2e` harness (it now rewrites every + relative `replace` directive — including `agenthub` — to an absolute path when + copying the livereload module, so that lane passes again). +- **`events` introspection** — `events/introspect` exposes the live topic/ + subscriber graph for tooling and the agent bridge. +- **Gesture primitives** (`anim`) — pure pan/drag and pinch primitives tracking + delta, velocity, center, scale, end-state, and zero-distance guards. +- **`gwc test -lane i18n`** — runs the message-extraction / locale-completeness + checks as a CI-addressable lane (included in `all`). + +- **Selective / progressive hydration (islands)** — `ui.HydrationIsland` marks + independently resumable SSR islands; `ui.HydrateIsland` schedules per-island + browser hydration on visible / interaction / idle / immediate triggers (with + optional timeout); `ui.ConfigureHydrationIslandBudget` caps concurrent island + hydration and `ui.InspectHydrationIslandBudget` validates startup/deferred + island plans. Attacks the wasm-startup gap directly. +- **Route-level code splitting** — router routes declare a `RouteChunk` via + `RegisterLazy` / `RegisterLazyRoute` or `Options.Chunk`; the router gates + rendering on the chunk, runs it before the route factory/loader, cancels stale + chunk loads on navigation, supports a custom `Loader` or script URLs, and + routes pending/error states through chunk- or route-local fallbacks. +- **`a11y` package** — headless menu, combobox, listbox, datepicker-grid, and + table builders over the overlay/focus/composite primitives, with semantic + HTML/ARIA contracts. +- **`servercomponents` package** — server-rendered component boundaries + (native + wasm split) for server-driven UI. +- **`telemetry` package** + `internal/telemetryredaction` — opt-in telemetry + with structured redaction of sensitive fields. +- **`scheduler` package** — a standalone cooperative task scheduler. +- **`agentbridge` package** — an agent-facing bridge surface over the framework. +- **Browser devtools extension** — `devtools` now generates a Chrome/Firefox + Manifest V3 and emits the stable `gwc.devtools.extension.v1` panel payload + (component tree, props/state inspection, extension sections / atom-graph + contributions, diagnostics, logs, commit profiling). +- **Agentic toolchain (`tools/gwc`)** — `agentic_toolchain` consolidates the + agent-facing tool surface. +- **Runtime controls & memory hygiene** (`internal/runtime`) — first-class + runtime controls, passive-event support, and memory-hygiene passes. + +- **`sanitize` package** — a DOMPurify-equivalent HTML sanitizer built on + `golang.org/x/net/html`: allowlisted tags/attributes/URL-schemes, drops + script/style/iframe/svg and `on*`/`style` attributes, unwraps unknown tags. +- **`events` package** — `UseTopic` typed in-app pub/sub fan-out bus with + lifecycle-tied subscriptions, replay-last opt-in, and panic-contained delivery. +- **`anim` package** — spring physics (semi-implicit Euler + presets), standard + easings with `Interpolate`, and `ComputeFLIP`. +- **`deprecation` package** — `Warn(api, replacement)` emits a one-time + `GWC-DEPRECATION` structured diagnostic. +- **`ui` hooks** — `UsePrefersReducedMotion`, `UsePrefersColorScheme`, and + `UsePersistedState[T]` (write-through + cross-tab sync + corrupt/quota-safe). +- **`fetch`** — declarative resilience (`RetryPolicy`, `CircuitBreaker`, + `ExecuteWithPolicy`) and `ScopeCacheKey` for the global cache namespace. +- **`flags`** — `RemoteProvider` for remote config (poll, fail-safe last-known- + good, staleness, kill-switch, contained payloads). +- **`i18n`** — `FormatRelativeTime` and `FormatList` (en/fr/ja/ar); new + `i18n/extract` message-extraction + locale-completeness tooling. +- **`interop`** — typed cookie helper (`GetCookie`/`SetCookie`/`ExpireCookie`), + `RequestPersistentStorage`/`IsStoragePersisted`, a WebCrypto bridge + (`GenerateAESKey`/`Encrypt`/`Decrypt` + `EncryptedStore`), and an opt-in + Browser Intl bridge (`IntlFormatNumber`/`IntlFormatDate`). +- **Streaming SSR** (`ui.RenderToStream`/`RenderToStreamObserved`) and + render-thread hook-threading enforcement (`GWC-RUNTIME-HOOK-THREADING`). +- **Versioned state-snapshot migration** in `hotreload` (app-owned + `snapshotVersion` + ordered migrations). +- **Crash containment** as the runtime default: panics in render/event/effect/ + cleanup/async are contained and reported as structured agent-readable + diagnostics instead of killing the page. +- **`gwc dev` auto-doctor** — environment diagnosis on dev-server failure, with + a `-no-doctor` opt-out. +- **Tooling & docs guards** — `docs/doclint` doc-drift guard (repo paths + + `gwc` flag existence), generated `docs/errorcodes` reference and + `docs/capabilities` matrix, and `tools/changelogcheck`. +- **Docs** — CONTRIBUTING.md, CONVENTIONS.md, SECURITY.md, + PRODUCTION_READINESS.md, ACCESSIBILITY.md, BENCHMARKS.md, the generated + error-code and capability-matrix pages, and committed `.vscode/` editor config. +- **Docs site** — generated favicon and OG/Twitter social-preview assets. + +### Changed + +- **Example 100 admin operations** — persisted user-list query state, surfaced + active/blocked status badges, added reasoned disable/restore confirmation, + wired billing access and quota override actions, and pinned admin wasm parser + coverage. +- **Atlas Commerce OS TODO closeout** — completed the remaining Atlas public, + internal, performance, accessibility, localization, preference, SEO, + recovery, and testing backlog markers with shipped code, docs, tests, and + screenshot evidence. +- **Starter feature matrices** — generated starter `FEATURE_MATRIX.md` files + now use explicit `selected` / `available` labels instead of unchecked + checklist boxes, keeping TODO scans focused on real backlog. + +- **ai-chat-wizard "Aurora" redesign** — ground-up design-token CSS system + (violet accent, Geist/Space Grotesk/Geist Mono type), open-canvas assistant + replies in a 46rem reading column, floating composer, and a framework-API + showcase: `anim` springs baked into CSS keyframes, `ui.UsePersistedState` + density toggle, `ui.UsePrefersReducedMotion`, `ui.UseAnnouncer` stream + completion, `i18n.FormatRelativeTime` sidebar timestamps, browser-ICU cost + formatting via `interop.IntlFormatNumber`, and the new shorthand helpers + (`MapKeyed`, `MapKeyedIndexed`, `Repeat`). +- **Go 1.26 toolchain** — root and `tools/livereload` go.mod bumped to + `go 1.26.0` (Green Tea GC by default, lower cgo overhead, better slice + stack-allocation), and the `go fix` modernizer suite applied module-wide + (~550 files): `interface{}` → `any`, `for i := range n`, built-in + `min`/`max`, `maps.`/`slices.` helpers, `strings.CutPrefix`/`SplitSeq`, + Go 1.26 `new(expr)`, and `wg.Go()`. Mechanical rewrites only; native and + js/wasm builds, vet, and package tests verified. +- **Lint-clean framework** — `gwc lint` (golangci-lint + gwc-hooks) now + reports zero issues across all 47 non-example packages (was 41: + errcheck/gosimple/ineffassign/staticcheck/unused/gwc-hooks). Dead helpers + removed, hook calls hoisted to named top-level component functions + (`virtualization` row body, `html.toHandler`, example tests), wasm-only + false positives annotated with reasons. +- README leads with a 30-second golden-path quickstart; capability summary and + Public Packages refreshed (i18n/interop/pwa/virtualization). +- Legacy `gwc` flag aliases (`-main`/`-index`/`-output`) are labeled deprecated + in help. +- Bumped `golang.org/x/net` to v0.55.0. + +### Performance + +- **Runtime inspector flamegraph collection** — `collectFlamegraphFrames` no + longer preallocates a fixed 256-frame backing array per call or copies the + full ancestor path at every node; it grows the result lazily, reuses one + push/pop path stack, and short-circuits at the frame limit. Cuts the + representative-scenarios inspector snapshot from ~36 KB to ~5.3 KB per op + (−85%) and ~1.9× faster, speeding up every devtools/agent snapshot query. +- **SSR attribute serialization** — `writeSSRProps`/`serializeProps`/ + `serializeStyleMap` collect attribute keys in a stack-allocated buffer and + sort with `slices.Sort` (no `sort.Interface` boxing), removing one heap slice + per host element during server-side rendering. +- **Telemetry redaction** — `redactValue` builds array element paths by string + concatenation instead of `fmt.Sprintf`, cutting ~26% of allocations and ~29% + of time on the redaction path that runs for every redacted telemetry record; + added the package's first benchmark (`BenchmarkRedactValueNestedArrays`). + +### Fixed + +- **GitHub Actions GoGRPCBridge gates** -- workflows now use the latest Go + `1.26.x` patch toolchain, check the canonical `GoGRPCBridge` module/path, + delegate bridge WASM example builds to the bridge runner, and install the + Playwright version used by the root module. + +- **Agent bridge hardening** — 18 defects found and fixed across six adversarial + review rounds, each regression-tested: a `SendCommand` socket-death bug + returning a zero-value ack with no error; the wasm client never stripping the + leading `?` so the bridge never activated from a real URL; mount/unmount + check-then-render TOCTOU races and a stuck-reservation leak; `bridge.undo`/ + `bridge.replay` bypassing the hub write lease; a data race on the runtime + replay buffer; `set-atom` silently accepting a wrong-typed value for a + concrete slice/map atom; a non-constant-time token compare; an unbounded undo + stack; `replay` silently resetting on double-start; an unbounded + predecessor-chain recursion; and missing audit-trail coverage on several + mutating commands. Real-browser dogfood verified after the fixes. +- `logging` (wasm) — console output now leads with the message string before + the structured record: the record object's console preview shows only a few + properties in nondeterministic Go-map order, which made messages unreadable + in devtools and browser-test log matching flaky. +- ai-chat-wizard — stub providers stream word-by-word with configurable pacing + (`CHAT_STUB_CHUNK_DELAY_MS`; `0` restores single-shot), fixing the + happy-path browser test that raced the instant single-delta stream; the + server also accepts the legacy `CHAT_STUB_PROVIDERS` spelling. +- `logging` — `slog.Attr` values passed as log args were collapsed to their + string form because the `fmt.Stringer` case matched first; Attrs now + normalize to key/value maps as intended. +- ai-chat-wizard example — admin redaction helpers shallow-copied generated + protobuf messages (copying their internal mutex, a `go vet` copylocks + violation); they now use `proto.Clone`. +- Repointed ~136 stale example paths across README, AGENTS.md, the reference + manual, and runbooks (the `examples/01-counter` → `examples/public/counter` + relocation and the renamed SSR/PWA examples), un-breaking the front-door + copy-paste quickstart commands. + +### Security + +- **Markdown URL-scheme XSS** — `html.RenderMarkdown` now allowlists + http/https/mailto/relative/# and drops `javascript:`/`data:`/`vbscript:` + (incl. obfuscated) in links, images, and autolinks. +- **Live-reload CSWSH** — the dev-server WebSocket validates the request Origin + against the dev host:port (opt-out `-allow-any-origin`, with a warning). +- **Raw-HTML sink removed** — `SetInnerHTML` is gone from the DOM adapter + interface and the wasm DOM, with a reflection guard preventing reintroduction. +- **Dependency CVEs** — the `golang.org/x/net` v0.55.0 bump clears 5 + govulncheck findings in the HTML parser; `govulncheck` now runs in CI + (informational) and SECURITY.md documents the disclosure policy. + +## 2026-04-08 + +### grouped examples layout and public site refresh + +- Reorganized the runnable examples into grouped `examples/public`, `examples/server`, and `examples/testing` trees, removed checked-in generated host HTML entrypoints, and updated repo docs, launcher paths, livereload expectations, and Playwright fixtures to match the new layout. +- Added `gwc examples build-public-site`, staged preview hosts plus mirrored source under `examples/public-examples-site/assets/`, and updated the Pages workflow to publish the renamed public examples site with embedded example wasm binaries. +- Introduced `examples/internal/exampleboot` plus selector-aware example logging so embedded and standalone public examples can share mount, hydrate, and keepalive behavior without duplicating host glue. + +### plugin runtime and devtools hardening follow-up + +- Fixed plugin host and internal plugin kernel cleanup and reboot behavior so closed kernels reject reuse, builtin services rebind on reboot, repeated host extension registration reference-counts correctly, and closed hosts drop stale contributions. +- Repaired runtime effect scheduling and early UI event capture so first-render effects still run after commit and kernel-backed UI event services can observe interactions before the first snapshot read. +- Replaced goroutine-based devtools snapshot polling on `js/wasm` with browser timers, broadened shorthand prop handling for the public examples site rendering surface, and tightened focused regression coverage around the repaired paths. + +### public examples site performance and cache lifetime fixes + +- Reduced the public examples browser hot path by deferring preview and source rendering until requested, turning debug event logging off by default, and falling back to plain source rendering for large files instead of always running the expensive tokenizer path. +- Added bounded Cache Storage handling for preview wasm binaries so the shell keeps only the current and most recent example builds, expires stale entries, removes superseded versions, and clears the older preview cache namespace to avoid steady RAM and storage growth. +- Regenerated the checked-in public examples shell plus preview hosts so the staged site reflects the deferred loading, bounded preview cache lifetime, and lighter browser-side rendering behavior. + +### public example presentation normalization + +- Restyled the shared example shell and the remaining bespoke public demos to match the compact counter example more closely, removing docs-like framing, trimming duplicate purpose copy, and emphasizing the live control surface. +- Added compact routed wrappers for the portfolio docs and not-found flows, then refreshed the mirrored `examples/public-examples-site/assets/code/` source tree so the public catalog reflects the clearer purpose-first example layouts. +- Applied the same compact text treatment to the generated preview host so the public examples browser de-emphasizes long explanatory paragraphs and oversized bullet lists across the staged catalog. + +## 2026-04-07 + +### core plugin kernel and first-pass devtools plugin + +- Added an internal plugin kernel plus typed interposer-backed services for runtime, router, fetch, UI, assets, security, and devtools so first-party plugins can reach deeply into framework state without binding to unstable runtime implementation details. +- Reworked `devtools` to compose app-owned sections and actions with kernel-owned plugin contributions, added the first-pass kernel bridge and capture service, and documented the new companion-host versus kernel split across the package docs and READMEs. +- Added the kernel-plugin devtools example and focused Playwright coverage proving the pluginized devtools flow renders live framework sections through the new kernel path. +- Added the implementation plan and granular implementation backlog docs for the plugin framework so the shipped kernel surface, rollout, and remaining follow-on work stay explicit. + +### wasm and browser regression hardening for the plugin pass + +- Fixed `ui.WrapHandler(...)` and parallel-region event bridging so late-installed bridged handlers are wrapped through the active DOM adapter instead of panicking or leaving stale host props cached in the runtime. +- Hardened `internal/platform/jsdom` append behavior for browser test shims, stabilized browser-compiler generator assertions across Windows line endings, restored the embedded livereload client asset, and taught `gwc tailwind` about Windows `arm64` binaries. +- Added focused native and `js/wasm` regression coverage around the repaired handler bridge, jsdom append fallback, and parallel-region worker event paths while also validating the broader non-example native, wasm, browser, and Playwright suites. + +### plugin-host devtools extension seam + +- Extended the `plugin` companion host with capability-gated devtools section and overlay-action providers so consumer-owned plugins can contribute richer diagnostics UI without widening runtime internals or relying on hidden discovery. +- Added `devtools.ApplyHostExtensions(...)` to map host-owned devtools contributions into the existing extension-section and error-overlay state, with cleanup that restores the prior app-owned devtools wiring. +- Covered the new seam with focused `plugin` and `devtools` tests for capability enforcement, cloned reads, rollback safety after failed setup, and host-to-devtools action-context mapping. + +### waitforever starter and example wiring cleanup + +- Added the production `utils.WaitForever()` stub so release-tag `js/wasm` programs can block on one named helper instead of open-coded `select {}` loops. +- Replaced raw `select {}` keeps-alive paths in Example 21, catalog implementation copy, launcher import output, launcher start output, and the starter golden files with `utils.WaitForever()` so the generated guidance and emitted app skeletons stay aligned. + +### example 100 customer-error fixture seeding cleanup + +- Simplified the Example 100 customer-error Playwright setup to reuse the deterministic happy-path database seeding helper instead of copying a prebuilt runtime fixture database from disk. + +### runtime2 renderer and benchmark performance pass + +- Reduced `runtime2` host and commit overhead with append-only and remove-only patch-transaction fast paths, narrower rollback snapshots, cheaper insert-only host patch cache handling, and focused compare benchmarks for the new commit paths. +- Cut `js/wasm` DOM bridge cost in `internal/platform/jsdom` and `internal/runtime` by caching prepared host mounts, reusing variadic batch buffers, keeping append batching active through child-order repair, and broadening reconciler optimization coverage and micro-benchmarks. +- Improved Example 201 worker-backed benchmark paths by adding worker-native parallel-region rendering hooks, more adaptive worker batching and cache reuse, and clearer worker timing diagnostics for the React 19 comparison runs. + +## 2026-04-06 + +### runtime1 render-path and example 201 benchmark pass + +- Reduced `runtime1` host-render overhead across reconciliation and DOM commit by separating host-only props, adding direct-text host storage, tightening compact host mount paths, caching component render metadata, and broadening targeted runtime coverage and benchmarks. +- Improved Example 201’s benchmark surface and harness by trimming unnecessary primitive/deep-tree benchmark work, updating the local React 19 benchmark bundle path, and fixing benchmark report gaps around worker metrics and score inputs. +- Validated the shipped `runtime1` slice with focused package tests plus the scoped Example 201 Playwright benchmark run instead of the unrelated broader browser suites. + +### core logging overhaul and wasm panic console capture + +- Reworked the core `logging` package into a shared structured record pipeline with native JSON-line output, browser `console.*` object output, low-ceremony key/value logging, and context-backed correlation plus trace enrichment. +- Added focused native and `js/wasm` logging coverage for variadic field normalization, context metadata propagation, stable slog-like record fields, and browser-console level mapping. +- Emitted framework-owned `js/wasm` panic reports as structured `console.error` records with slog-like level metadata, documented the panic-reporting contract in the reference manual, and added focused browser tests for panic capture plus hidden raw rethrow suppression. + +### reference manual consolidation and api browser + +- Replaced the fragmented top-level `docs/*.md` app-authoring set with a consolidated `docs/REFERENCE_MANUAL/` chapter set and removed the legacy duplicate docs from the repository. +- Added ordered topic pagination across the manual plus a dense `16-api-browser.md` chapter that catalogs the public packages, high-level usage, key parameter objects, returned handles, and source anchors. +- Rewired root docs, package READMEs, example READMEs, agent guidance, and devtools doc pointers to point at the consolidated manual, and removed the obsolete docs-ingestion planning and `tools/doc_ingest/` assets. + +### browser compatibility workflow checkout + +- Updated `.github/workflows/browser-compatibility.yml` to fetch submodules recursively so CI jobs that depend on the pinned `third_party/GoGRPCBridge` checkout can resolve modules and compile the browser suite. + +### core runtime state and virtualization coverage cleanup + +- Fixed a public `ui.ParallelRegion(...)` panic path by guarding `reflect.Value.IsNil()` behind nilable-kind checks. +- Fixed mixed keyed and unkeyed child reordering in `internal/runtime/` so reused DOM nodes are moved into their committed sibling order instead of being left in stale positions. +- Split browser-only virtualization helpers into focused native and wasm files, normalized persisted restoration JSON keys to `scrollTop` and `anchorKey`, and expanded `state`, `virtualization`, and `mockdom` coverage around the repaired paths. + +### runtime2 coverage and patch helper hardening + +- Fixed `internal/runtime2` style canonicalization so map-backed styles normalize the same way as equivalent string styles, including trimmed scalar values. +- Added broad regression coverage across runtime2 patch-building, snapshot hashing, host-region, recovery, and transport helpers so the remaining low files in `internal/runtime2/` clear the per-file coverage floor. + +### fetch native coverage and cache correctness + +- Split browser-only fetch and upload transport code out of `fetch/fetch.go` into focused wasm and native files so shared cache and mutation logic is testable off-wasm. +- Fixed stale cached-resource handle mutations after disposal or replacement, canceled in-flight loads before optimistic cache updates, retried persistent cache-store opens after failures, honored `DeleteOnCorruption`, and treated nil response bodies as empty text instead of `""`. + +### browser support coverage and interop guards + +- Removed unused browser-storage batching code from `interop/interop_wasm.go` and aligned the wasm tests with native JavaScript throw behavior instead of Go callback panics. +- Hardened hot-reload bridge registration cleanup, preserved structured console envelope keys under collisions, clarified browser console window-error field names, and expanded `devtools`, `router`, `logging`, `hotreload`, `i18n`, `interop`, and `utils` wasm coverage. + +### pwa promise guards and wasm coverage + +- Fixed `pwa` service worker, cache storage, and installability await helpers so primitive browser return values no longer panic when inspected for promise methods under `syscall/js`. +- Added focused GoDocs and intent comments to the repaired `pwa` browser helpers and expanded wasm coverage for service worker lifecycle, cache diagnostics, and installability error handling. + +### repository navigation refresh + +- Added a human-first repository map in `docs/REPO_MAP.md` and linked it from the root README and docs index. +- Added or tightened local entry docs for `bin/`, `log/`, `third_party/`, `internal/`, `ui/`, and `interop/` so contributors can find the right starting points faster. +- Updated ignore rules so local runtime outputs stay out of source control while the new folder READMEs remain tracked. + +### core runtime hot-path and wasm storage cleanup + +- Replaced several formatting and normalization hot paths with cheaper builders across `internal/runtime/` and `internal/runtime2/`, including hook IDs, renderer feature-flag lookup, render-style scalar formatting, remove-attr dedupe keys, and scheduler shard IDs. +- Added focused benchmark coverage for those core fast paths so the new implementations are compared directly against the legacy paths. +- Hardened `interop/interop_wasm.go` storage access so non-callable browser storage methods return structured errors instead of panicking. + +### chat-wizard managed start and seeding alignment + +- Aligned Example 100 seeding and server runtime to the same default `chat_history.db` path. +- Taught `gwc` managed chat-wizard start flows to auto-seed missing or empty local databases and to build the client and background-worker wasm artifacts plus Brotli sidecars before launch. +- Updated the managed-start tests and operator smoke docs to match the repaired launch and seed flow. + +### example 100 runtime fallback and copy refresh + +- Made the composer `runtime2` display region fail open to inline rendering instead of panicking the app when region registration fails. +- Fixed nil-billing handling in the account cost view so missing billing responses no longer imply a configured platform fee. +- Corrected Example 100 README, in-app dev-tool pointers, and fallback catalog copy so the documented capabilities match the shipped example more closely. + +### example 100 worker render performance pass + +- Reduced redundant client worker work by gating refreshes on signatures, pruning request payloads, and removing extra clone staging before async worker dispatch. +- Replaced large concatenated signature strings with compact rolling-hash signatures in the app and worker paths. +- Reworked metadata extraction and conversion in the background worker to avoid full-content string copies, regex-heavy fenced-block parsing, and repeated label or fence normalization overhead, with focused wasm benchmark coverage for each step. + +### runtime2 dispatch hashing and patch fallback + +- Added typed scalar slice and typed `map[string]scalar` fast paths to the buffered and streamed runtime2 dispatch-hash encoders, along with regression coverage and compare benches. +- Taught canonical patch diffing to fall back to `replace-subtree` for root-ID structural deltas and added canonical DOM snapshot seeding for rebuilding region DOM state from canonical IR. + +### public parallel-region click bridge + +- Added runtime2 semantic event control envelopes, worker event dispatch handling, metadata-only registry lookup and mutation helpers, and metadata-aware worker renderer registration. +- Added `html.OnClickParallel(...)` and a bounded browser click bridge so local-first `ui.ParallelRegion(...)` nodes preserve their local click handlers while forwarding one semantic click event into runtime2 and committing the resulting worker patch. +- Seeded worker region state from already-rendered public nodes for post-mount patching and refreshed the runtime2 authoring and backlog docs to match the shipped behavior. + +### GoGRPCBridge metadata forwarding + +- Updated the pinned `third_party/GoGRPCBridge` submodule so grpctunnel forwards request ID, correlation ID, `traceparent`, and `tracestate` bridge headers into backend gRPC metadata. +- Added focused grpctunnel coverage proving the forwarded metadata reaches backend unary handlers. + +## 2026-04-05 + +### runtime2 event-slot metadata + +- Replaced the non-operative placeholder event-slot metadata slice with a normalized `v1` schema in `internal/runtime2/`. +- Added validation and transport coverage for declared slot and event pairs, legacy placeholder-version normalization, and duplicate or malformed slot rejection. +- Wired event-slot metadata through the runtime2 renderer registry so renderer capability metadata now carries validated slot declarations. +- Kept the legacy placeholder JSON helper names as compatibility wrappers over the normalized event-slot transport path and updated the runtime design notes to drop stale placeholder wording. + +### plugin support-tier promotion + +- Promoted `plugin` from experimental to supported companion in the package docs, root README, API policy, ecosystem docs, and comparison notes. +- Updated the first-party `examples/99-plugin-host` copy so the example matches the supported-companion classification. + +### core runtime and platform package refactors + +- Split several oversized core files into smaller focused units across `devtools/`, `fetch/`, `internal/runtime/`, `internal/runtime2/`, `interop/`, `router/`, `testkit/render/`, and `ui/` without changing the public package layout. +- Hardened core runtime behavior and coverage: + - tightened `internal/runtime` adapter and scheduler contract coverage + - fixed `utils` goroutine-monitor lifecycle handling for `js/wasm` + - clarified `DOMNode` contract handling and expanded `mockdom` and `jsdom` validation + - restored runtime2 shard and host-region invariants with targeted regression and benchmark coverage + +### gwc tooling and livereload refactors + +- Split large `tools/gwc` command files into focused command helpers for benching, imports, release, startup rendering, test lanes, wasm variants, verification, and doctor flows. +- Split `tools/livereload` into HTTP, path, and support helpers and kept `gwc dev` aligned with the full livereload source set. +- Updated starter scaffold output and the matching goldens, and added the `fsnotify` module requirement needed by the current tooling path. + +### example app refactors and fixes + +- Split several oversized example files in `examples/00-example-0`, `examples/14-omi`, and `examples/server/ai-chat-wizard` into smaller focused files. +- Refreshed example-backed docs and router snippets to match the shipped public router surface. +- Landed focused example fixes around the portfolio contact form, seeded test expectations, readonly ops reporting, billing normalization, logging redaction, and SSO SQL paths. + +### docs backlog and reference refresh + +- Reduced `docs/TODO.md` to the active backlog, removed completed execution history from the root todo file, and refreshed the remaining maintainability notes. +- Updated `docs/MULTITHREADED_RUNTIME_TODO.md` to reflect the runtime2 work that has already landed. +- Refreshed related reference docs and editor snippets in `docs/ACCESSIBILITY.md`, `docs/API_POLICY.md`, `docs/ERROR_BOUNDARIES.md`, `docs/IDE_INTEGRATION.md`, `docs/MIGRATIONS.md`, `docs/VIRTUALIZATION.md`, `docs/WORKFLOWS.md`, and `docs/examples/gwc-vscode.code-snippets.json`. + +### docs ingestion planning assets + +- Added `docs/DOC_INGESTION_PLAN.md` and `docs/DOC_INGESTION_TODOS.md` to capture the repository docs-ingestion design and approval flow. +- Added `docs/docs.sql` and `docs/seed_docs.ps1` to define and seed the docs-ingestion schema. + +### repository layout maps + +- Added a repo-layout section to `README.md` so contributors can quickly locate the public packages, internals, tests, tools, docs, examples, and local helper folders. +- Added local navigation READMEs for `agents/`, `scripts/`, `internal/platform/`, `internal/runtime/`, `internal/runtime2/`, and `tools/runnerconfig/`. +- Tightened `docs/README.md`, `internal/README.md`, and related folder maps so the larger implementation areas are easier to navigate without scanning the tree by hand. + +### docs ingest tooling cleanup + +- Moved the executable docs-ingestion assets out of `docs/` and into `tools/doc_ingest/` so the docs folder stays prose-first. +- Replaced the giant checked-in docs-ingestion SQL snapshot with a compact `tools/doc_ingest/schema.sql` schema file and a runnable `tools/doc_ingest/seed.ps1` local seed flow. +- Updated the docs-ingestion plan, todo notes, and tools docs to point generated outputs at `bin/doc_ingest/` instead of writing databases and temp files back into `docs/`. + +### readme presentation refresh + +- Replaced the README hero image with the new ChatGPT-generated artwork and moved the asset into `docs/assets/chatgpt.png` so the top-level repo no longer carries the long original image filename. + +## 2026-03-28 + +### example 100: admin operator drilldowns, mutations, and rollups + +- Expanded `examples/server/ai-chat-wizard` admin/operator backend coverage: + - added typed business queue/detail, customer timeline, chats anomalies, providers drilldown, provider mutation, ops drilldown, and ops mutation RPC contracts in `proto/chat.proto` + - added matching server handlers and focused tests under `server/app/` for the new dashboard/admin surfaces + - added typed query/store wiring for customer timeline, billing dunning, failed payments, chat anomalies, provider routing/guardrails, and provider usage rollups +- Added supporting persistence and UI followups: + - introduced provider usage daily rollup schema/migration support plus admin SQL files under `examples/server/ai-chat-wizard/sql/store/` + - regenerated `proto/chat.pb.go` and `proto/chat_grpc.pb.go` + - wired the business dashboard slice to reuse the workspace panel in `client/app/dashboard.go` and `client/app/dashboard_shell.go` + +### docs and interop: worker validation fixes and demo backlog shaping + +- Tightened browser interop contracts in `interop/interop_wasm.go`: + - validate unsupported worker types before browser-surface discovery + - resolve Go-worker URLs without assuming `document` exists + - report closed popup peers as disposed for `WindowChannel.Focus` and `WindowChannel.Close` +- Fixed and expanded js/wasm validation in `interop/interop_wasm_test.go` for worker surfaces, cross-surface malformed-envelope handling, and structured-clone boundary failures +- Updated backlog/changelog tracking in `docs/TODO.md`, `examples/server/ai-chat-wizard/TODO.md`, and `examples/server/ai-chat-wizard/CHANGELOG.md` + +### example 100: provider drilldown contracts, workspace followups, and worker interop validation + +- Added follow-up provider drilldown scaffolding in `examples/server/ai-chat-wizard`: + - introduced typed `GetAdminProvidersDrilldown` request/response contracts and `AdminProvidersDrilldownSummary` in `proto/chat.proto` + - added `WorkspaceModelRoutingPolicyEntry` to the shared admin/control-plane proto surface + - added store-side workspace model-routing policy row loading in `server/app/store_superuser.go` +- Added supporting workspace/admin wiring: + - introduced `sql/store/ops/list_workspace_model_routing_policies.sql` and query-loader wiring in `server/app/queries.go` + - applied small workspace-admin shell/table followups in `client/app/admin_workspaces.go`, `client/app/app.go`, and `client/app/app_shell.go` +- Expanded browser-lane worker interop validation in `interop/interop_wasm_test.go`: + - direct coverage for empty worker URLs, unsupported worker types, empty request names, nil subscribe handlers, and Go-wasm worker URL/bootstrap descriptor failures +- Updated follow-up backlog tracking in `docs/TODO.md` + +### example 100: cache core, admin operations, billing surfaces, and interop regression coverage + +- Expanded `examples/server/ai-chat-wizard` with a reusable client cache subsystem and policy layer: + - added `client/cachecore/` with shared scoped-record, SWR, invalidation, retry, storage, snapshot, worker-contract, and reconciliation primitives + - added `client/cachepolicy/` with example-owned policies for dashboard, billing, thread, locale, catalog, and outbox resources + - extended the background worker with maintenance-plan support and runtime wiring in `client/backgroundworker/` +- Broadened Example 100 product and admin surfaces across client, server, proto, and SQL: + - updated client app state and views in `client/app/` for admin workspaces, account costs, profile/runtime data, and related shell constants + - added or expanded server-side admin, customer-billing, pricing-page, conversation-metadata, public-auth, and superuser diagnostics handlers in `server/app/` + - updated billing/store logic, formula guards, and plan/invoice persistence in `server/app/` plus `sql/store/` + - regenerated `proto/chat.pb.go` and `proto/chat_grpc.pb.go` after `proto/chat.proto` changes +- Expanded regression coverage: + - deeper browser interop wasm coverage in `interop/interop_wasm_test.go` + - broader Example 100 Playwright coverage for admin journeys, authenticated flows, customer-safe error surfaces, and the full-stack demo sweep +- Updated backlog and project notes in `docs/TODO.md` and `examples/server/ai-chat-wizard/TODO.md`, and refreshed supporting example shell CSS in `examples/static/css/tailwind.css` + +### example 100: admin dashboard data layer + five slice UIs + +- Added live admin data fetching and full slice-level UI across the admin dashboard in `examples/server/ai-chat-wizard`: + - Created `client/app/admin_data.go` with: + - `adminDashboardData` render-only snapshot type and flat row types (`adminSummarySnapshot`, `adminUserRow`, `adminConvRow`, `adminProviderRow`, `adminDailyRow`) + - `parseUseAdminDashboard` hook — async gRPC call to `GetAdminDashboard` with 30-day window, sequence-tracked cancellation, and loading / denied / error state transitions + - `parseMarshalAdminDashboardResp` converter from proto response to flat snapshot + - Extended `appViewState` in `client/app/app_shell.go` with `AdminDashboardData adminDashboardData` field; added `parseAdminDashboard` as the 10th parameter of `parseDeriveAppViewState` + - Wired the hook in `client/app/app.go` after `parseUseAccountCostSummary`; updated `parseDeriveAppViewState` call accordingly + - Registered all six dashboard routes explicitly in `ParseRun()` (`/app/dashboard`, `/app/dashboard/business`, `/app/dashboard/customers`, `/app/dashboard/chats`, `/app/dashboard/providers`, `/app/dashboard/ops`) + - Rewrote `client/app/dashboard.go` with: + - Path-based dispatcher `renderDashboardBody` routing to five slice renderers from a shared `renderDashboardSliceWrap` scroll container + - Context-aware top bar (Back to Dashboard vs Back to workspace) + - Slice tiles upgraded to real `` links (`IsReady: true` on all five) + - **Business** slice: platform-total KPI grid, 30-day window KPI grid, top-users-by-spend table, daily usage trend table + - **Customers** slice: total-user count pill, recent-users table (display name, email, convs, messages, spend, joined, last seen) + - **Chats** slice: conversation KPI cards, recent-conversations table with truncated preview, message count, cost, and last-activity date + - **Providers** slice: provider health status table (label, available/not-configured status, auth, latency, request count, last error) + - **Ops** slice: open-incidents, support-tickets, active-experiments, failed-events KPI grid + daily usage table + - Shared primitives: `renderDashboardLoadingState`, `renderDashboardEmptyState`, `renderDashboardDeniedBanner`, `renderDashboardErrorBanner`, `renderDashboardTable`, `renderDashboardKPICard`, `renderDashboardSectionHeader`, `renderDashboardSliceHeader` + - Formatting helpers: `formatDashboardInt64`, `parseDashboardUserLabel`, `parseDashboardShortAt`, `parseDashboardBool` +- Marked eight TODO items as complete in `examples/server/ai-chat-wizard/TODO.md` +- Validation: + - `$env:GOOS="js" ; $env:GOARCH="wasm" ; go build ./examples/server/ai-chat-wizard/client/app/...` + - `$env:GOOS="js" ; $env:GOARCH="wasm" ; go build ./examples/server/ai-chat-wizard/client/...` + +## 2026-03-27 (continued) + +### example 100 + router: history fragments, shell-route coverage, and landing boot cleanup + +- Fixed several route and first-paint regressions across `examples/server/ai-chat-wizard` and the shared router: + - client-side landing/login navigation no longer treats `/home -> /` as a no-op + - extensionless `/app/...` routes like `/app/settings?panel=settings-profile` now serve the client shell instead of 404ing + - pricing-page fragment routes now work on initial load, click, and browser back/forward for `/pricing#plans` and `/pricing#faq` + - history-router core now preserves `#fragment` targets and rerenders on `hashchange` +- Fixed public-route loading flashes in example 100: + - landing routes now bypass the auth-loading shell and render marketing content immediately after hydration + - the bootstrap overlay uses route-aware copy for marketing pages + - the bootstrap overlay is removed from the DOM after mount so stale boot text cannot reflow after hydration +- Added focused regression coverage in: + - `router/browser_router_test.go` + - `examples/server/ai-chat-wizard/client/app/route_sync_test.go` + - `examples/server/ai-chat-wizard/client/app/marketing_fragment_test.go` + - `examples/server/ai-chat-wizard/client/app/app_shell_test.go` + - `examples/server/ai-chat-wizard/server/app/runtime_helpers_additional_test.go` +- Validation: + - `go test -exec "C:\Users\Cam\Desktop\GoWebComponents\tools\go_js_wasm_exec.bat" ./router -run TestBrowserRouterNavigateHistoryFragmentPreservesPath` + - `go test -exec "C:\Users\Cam\Desktop\GoWebComponents\tools\go_js_wasm_exec.bat" ./router -run TestBrowserRouterNavigateHistoryTargetPreservesFragment` + - `go test -exec "C:\Users\Cam\Desktop\GoWebComponents\tools\go_js_wasm_exec.bat" ./router -run TestBrowserRouterNavigateReplaceHistoryFragmentPreservesPath` + - `go test -exec "C:\Users\Cam\Desktop\GoWebComponents\tools\go_js_wasm_exec.bat" ./router -run TestBrowserRouterHistoryHashchangeRerendersCurrentRoute` + - `go test -exec "C:\Users\Cam\Desktop\GoWebComponents\tools\go_js_wasm_exec.bat" ./examples/server/ai-chat-wizard/client/app -run TestShouldNavigateLandingRoute` + - `go test -exec "C:\Users\Cam\Desktop\GoWebComponents\tools\go_js_wasm_exec.bat" ./examples/server/ai-chat-wizard/client/app -run TestParseResolvePricingFragmentScroll` + - `go test -exec "C:\Users\Cam\Desktop\GoWebComponents\tools\go_js_wasm_exec.bat" ./examples/server/ai-chat-wizard/client/app -run TestShouldRenderLandingShellEarly` + - `go test ./examples/server/ai-chat-wizard/server/app -run TestChatBootstrapLoaderTracksDownloadPhase` + - `go run ./examples/server/ai-chat-wizard/cmd/build-client` + - `go build ./examples/server/ai-chat-wizard/cmd/server` + - live browser smoke against `http://127.0.0.1:8095/`, `/pricing#faq`, and `/app/settings?panel=settings-profile` + +### example 100: operational schema coverage + table inventory + +- Expanded `examples/server/ai-chat-wizard` schema/migration coverage for operational SaaS workflows with new tables for: + - auth/session lifecycle: `auth_sessions`, `auth_token_versions`, `password_reset_tokens`, `email_verification_tokens` + - workspace operations: `workspace_invitations` + - webhook delivery history: `webhook_deliveries` + - support threading: `support_ticket_messages` + - incident timelines: `incident_updates` + - async operations: `notification_outbox`, `background_jobs` +- Added a schema reference document at `examples/server/ai-chat-wizard/SCHEMA_TABLES.md` that lists each table, its columns, and its purpose. +- Validation: + - `sqlite3 :memory: ".read examples/server/ai-chat-wizard/sql/store/schema.sql"` + - replay-safe migration validation against a temp SQLite database + - `go test ./examples/server/ai-chat-wizard/proto` + +### example 100: authenticated token usage traceability for billing + +- Added immutable usage-event persistence for `examples/server/ai-chat-wizard` so each logged-in completion can be audited for billing: + - schema/migration updates in: + - `examples/server/ai-chat-wizard/sql/store/schema.sql` + - `examples/server/ai-chat-wizard/sql/store/migrations.sql` + - new SQL queries: + - `examples/server/ai-chat-wizard/sql/store/save_usage_event.sql` + - `examples/server/ai-chat-wizard/sql/store/list_usage_events.sql` + - `examples/server/ai-chat-wizard/sql/store/get_model_pricing.sql` +- Extended provider and transport usage metadata: + - `provider.ChatResult` now carries `usage_source` and `provider_request_id` with provider implementations updated in: + - `examples/server/ai-chat-wizard/server/provider/openai_provider.go` + - `examples/server/ai-chat-wizard/server/provider/anthropic_provider.go` + - `examples/server/ai-chat-wizard/server/provider/cerebras_provider.go` + - `examples/server/ai-chat-wizard/server/provider/stub_provider.go` + - final `ChatChunk` now includes: + - `usage_event_id` + - `provider_id` + - `total_cost_usd` + - `usage_source` + - `usage_persisted` + - proto changes in: + - `examples/server/ai-chat-wizard/proto/chat.proto` + - regenerated `chat.pb.go` and `chat_grpc.pb.go` +- `Send` server flow now snapshots event-time pricing and persists both: + - successful completion usage events (`status=completed`) + - failed-stream usage events (`status=failed`) for reconciliation parity + - in `examples/server/ai-chat-wizard/server/app/server.go` and store plumbing in `store.go`/`queries.go` +- Added plan-aware auto model routing for authenticated sends: + - revised billing SQL/table definitions with `billing_plan_model_access` + - new effective-plan model query `list_billing_effective_model_access_by_user.sql` + - `Send` now auto-selects the plan default model when request model is blank + - model preference RPCs now apply effective plan model policy and persistence repair +- Added focused tests and micro-benches: + - store usage lifecycle/scoping/pricing tests in `examples/server/ai-chat-wizard/server/app/store_test.go` + - success + error stream usage assertions in: + - `examples/server/ai-chat-wizard/server/app/rpc_test.go` + - `examples/server/ai-chat-wizard/server/app/rpc_additional_test.go` + - provider usage metadata assertions in: + - `examples/server/ai-chat-wizard/server/provider/stub_provider_test.go` + - `examples/server/ai-chat-wizard/server/provider/provider_streaming_additional_test.go` + - usage micro-benches in `examples/server/ai-chat-wizard/server/app/benchmark_test.go` +- Validation: + - `go test ./examples/server/ai-chat-wizard/server/app` + - `go test ./examples/server/ai-chat-wizard/server/provider ./examples/server/ai-chat-wizard/proto` + - `go test ./examples/server/ai-chat-wizard/server/app -run ^$ -bench "BenchmarkStoreCorePaths/(save_usage_event|list_usage_events)$" -benchtime=1x` + - `go run ./tools/gwc test -lane unit -app .\examples\server\ai-chat-wizard\cmd\server\main.go -root .\examples\server\ai-chat-wizard` + +### examples and tooling cleanup: example 203 + three-digit catalog support + +- Added the new `examples/203-use-state-rerender-trace` state example, including: + - `examples/203-use-state-rerender-trace/main.go` + - `examples/203-use-state-rerender-trace/use-state-rerender-trace.html` + - docs updates in `examples/README.md` and `examples/MANUAL_TESTING.md` +- Updated example discovery in `tools/gwc/examples.go` from `^\d{2}-` to `^\d+-` so three-digit example folders are included, and added focused coverage in `tools/gwc/examples_test.go`. +- Tightened `gwc` livereload client-script resolution wiring in `tools/gwc/dev.go` and `tools/gwc/main.go`, with supporting test updates. +- Added non-js/wasm build constraints for static export helpers in `examples/102-static-export-site/site.go` and `examples/102-static-export-site/export_test.go`. +- Included cleanup and dead-code removals across examples, interop, testkit, and wasm/native helper packages to keep package builds warning-free and reduce unused wrappers. +- Validation: + - `go test ./tools/gwc -run "Test(BuildExamplesListingIncludesThreeDigitExamples|ResolveLauncherLivereloadClientScriptUsesOverride|ResolveLauncherLivereloadHelpersCoverDefaultsAndErrors)" -count=1` + - `go test ./examples/102-static-export-site -run Test -count=1` + +### runtime2 dispatch pressure pass: fast-hash streaming + coordinator read collapse + +- Applied one focused dispatch hot-path optimization set in: + - `internal/runtime2/snapshot_dispatch_hash.go` + - `internal/runtime2/host_region_adapter.go` + - `internal/runtime2/coordinator.go` +- Runtime changes: + - `buildSnapshotDispatchFastHashIntoWithSourceAndPropsKeys(...)` now streams canonical envelope/props/source encoding directly into one pooled `maphash.Hash` (`writeSnapshotDispatchFastHashEnvelopeWithSourceAndPropsKeys(...)`) instead of staging a single combined payload byte slice before hashing. + - Added `Coordinator.GetEntrySnapshotAndDispatchFields(...)` so snapshot capture can read epoch/renderer/source IDs plus fallback/monotonic dispatch fields in one `RLock` round. + - `handleHostRegionUpdateSnapshot(...)` now returns those dispatch validation fields, and `handleHostRegionUpdateDispatchWithKnownPriority(...)` reuses them instead of issuing a second coordinator read. +- Validation: + - `go test ./internal/runtime2 -run "Test(BuildSnapshotDispatchFastHashIntoWithSourceIDsMatchesBuffered|BuildSnapshotDispatchFastHashIntoWithSourceAndPropsKeysMatchesBuffered|HandleHostRegionDispatchHash.*|HandleHostRegionUpdateDispatch(ShortCircuitsNoChange|NoChangeDoesNotAdvanceDispatchedVersion))$" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(BuildSnapshotDispatchFastHashCurrentVsLegacy|HandleHostRegionDispatchHashCurrentVsLegacy|HandleHostRegionSnapshotHashPrefilterCurrentVsLegacy|HandleHostRegionManyHotRegionsBoundedWorkers)$" -benchmem -count=3` + - `go test -c -o ./bin/runtime2.test.exe ./internal/runtime2` + - `./bin/runtime2.test.exe --% -test.run=^$ -test.bench=BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$ -test.benchtime=10s -test.cpuprofile=./bin/runtime2.hot.cpu.pprof` + - `go tool pprof -top ./bin/runtime2.hot.cpu.pprof` +- Benchmark/profile snapshot (Windows/amd64, i7-12700): + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: `~12.3-12.6 us/op`, `383-384 B/op`, `47 allocs/op` + - latest pprof top no longer shows `buildSnapshotDispatchFastHash` or `maps.(*Iter).Next` as top nodes; `runtime.duffcopy` dropped to about `3.2% flat` in the latest 10s capture. + +### runtime2 dispatch pressure pass: adapter coordinator cache + fast-hash write batching + +- Applied one additional dispatch hot-path optimization set in: + - `internal/runtime2/host_region_adapter.go` + - `internal/runtime2/snapshot_dispatch_hash.go` +- Runtime changes: + - Added adapter-local cached coordinator snapshot or dispatch fields (epoch, renderer, source IDs, last snapshot version, last dispatched version) and used them on the dispatch-driven snapshot-capture path (`handleHostRegionUpdateSnapshot(..., parseShouldStoreSnapshotVersion=false)`) so urgent dispatch avoids a separate coordinator `RLock` read on every update. + - Wired cache updates through mount/dispose/remount and snapshot/dispatch write paths so monotonic snapshot and dispatch state stays in sync with coordinator writes. + - Reduced fast-hash overhead by batching marker+length writes (`writeSnapshotDispatchFastHashByteAndUint64(...)`, `writeSnapshotDispatchFastHashByteAndByte(...)`) and using `maphash.Hash.WriteString(...)` for string payload writes. +- Validation: + - `go test ./internal/runtime2 -run "Test(HandleHostRegionUpdateDispatch.*|HandleHostRegionUpdateSnapshot.*|HandleHostRegionWorkerDeath.*|HandleHostRegionRepairRemount.*|HandleHostRegionStructuralRemount.*)$" -count=1` + - `go test ./internal/runtime2 -run "Test(BuildSnapshotDispatchFastHashIntoWithSourceIDsMatchesBuffered|BuildSnapshotDispatchFastHashIntoWithSourceAndPropsKeysMatchesBuffered|HandleHostRegionDispatchHash.*|HandleHostRegionUpdateDispatch.*)$" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(HandleHostRegionManyHotRegionsBoundedWorkers|HandleHostRegionDispatchHashCurrentVsLegacy|BuildSnapshotDispatchFastHashCurrentVsLegacy)$" -benchmem -count=3` + - `go test -c -o ./bin/runtime2.test.exe ./internal/runtime2` + - `./bin/runtime2.test.exe --% -test.run=^$ -test.bench=BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$ -test.benchtime=10s -test.cpuprofile=./bin/runtime2.hot.cpu.pprof` + - `go tool pprof -top ./bin/runtime2.hot.cpu.pprof` +- Benchmark/profile snapshot (Windows/amd64, i7-12700): + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers` improved from pre-pass `~17.9-21.2 us/op` to post-pass `~11.6-15.4 us/op` in the same compare command (`383 B/op`, `47 allocs/op` unchanged). + - `BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/stable_payload_current_digest_guard` improved from roughly `~812-905 ns/op` to `~694-746 ns/op`. + - `BenchmarkBuildSnapshotDispatchFastHashCurrentVsLegacy/current_streamed_maphash` stayed in-band (`~1.34-1.65 us/op` before vs `~1.44-1.52 us/op` after; no alloc change). + - Recent pprof captures show lock/hash-pressure reductions on the hot path (`sync/atomic.(*Int32).Add` around `~2.7-3.0% flat`, `hash/maphash.(*Hash).Write` around `~4.2-5.3% flat`). + - Note: `go test ./internal/runtime2` in this worktree is currently red due unrelated existing failures (`TestBuildSchedulerCanonicalizesShardIDsForLookup`, `TestDuplicateKeySiblingCanonicalBuildFails`), so this pass was validated with focused suites and microbenches. + +### runtime2 binary source decode and source-id validation tightening + +- Reviewed recent runtime2 commits and added missing changelog detail for: + - `1b7efb5` (`tighten runtime2 binary source decode paths`) + - `272fbd0` (`tighten runtime2 binary source id validation`) +- Runtime changes: + - `internal/runtime2/binary_source_value.go` + - split `ParseBinarySourceValue(...)` into scalar-first and composite decode paths (`parseBinarySourceScalarValue(...)` and `parseBinarySourceCompositeValue(...)`), + - updated list/map decode loops to use scalar fast handling before recursive composite decode. + - `internal/runtime2/binary_source_id_table.go` + - tightened append/parse length handling with trusted append path and explicit capacity reservation, + - tightened source-ID validation with an ASCII fast path plus UTF-8 fallback (`isBinarySourceIDByteValid(...)` + `utf8.DecodeRuneInString(...)`) so invalid bytes/runes fail deterministically. +- Validation: + - `go test ./internal/runtime2 -run "Test(BuildBinarySourceIDTableRoundTripsCanonicalIDs|ParseBinarySourceIDTableRejectsNonCanonicalOrder|BuildBinarySourceValueRoundTripsScalars|BuildBinarySourceValueRoundTripsSmallList|BuildBinarySourceValueRoundTripsNestedMap|BuildBinarySourceValueRejectsUnsupportedKind)$" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(BinarySourceIDTableCurrentVsLegacy|ParseBinarySourceValueNestedCurrentVsLegacy)$" -benchmem -count=3` +- Benchmark snapshot (Windows/amd64, i7-12700): + - source-id append: `legacy ~94-107 ns/op, 240 B/op, 4 allocs/op` -> `current ~60-65 ns/op, 128 B/op, 2 allocs/op` + - source-id parse: parity (`legacy ~269-289 ns/op` vs `current ~275-288 ns/op`, both `240 B/op, 9 allocs/op`) + - nested source-value parse: slight improvement (`legacy ~1641-1691 ns/op` vs `current ~1564-1634 ns/op`, both `2880 B/op, 58 allocs/op`) + +### runtime2 binary source-id table capacity pass + +- Completed the next runtime2 perf todo in `internal/runtime2/binary_source_id_table.go`: + - `appendBinarySourceIDTableFromNormalized(...)` now computes exact encoded length (`getBinarySourceIDTableLengthFromNormalized(...)`) and reserves destination capacity once (`getBinarySourceIDTablePayloadWithCapacity(...)`) before writing. + - Kept parse validation behavior intact while refreshing compare-bench coverage in `internal/runtime2/perf_binary_source_id_table_compare_bench_test.go`. +- Validation: + - `go test ./internal/runtime2 -run "Test(BuildBinarySourceIDTableRoundTripsCanonicalIDs|ParseBinarySourceIDTableRejectsNonCanonicalOrder|BuildBinarySnapshotEnvelopeRoundTrips|ParseBinarySnapshotEnvelopeRejectsTruncatedPayload|ParseBinarySnapshotEnvelopeRejectsIncorrectLength)$" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(ParseBinarySourceIDTableCanonical|BinarySourceIDTableCurrentVsLegacy)$" -benchmem -count=3` +- Benchmark snapshot (Windows/amd64, i7-12700): + - append: `legacy ~92.7-110.9 ns/op, 240 B/op, 4 allocs/op` -> `current ~62.5-75.5 ns/op, 128 B/op, 2 allocs/op` + - parse: parity (`legacy ~271-307 ns/op` vs `current ~269-279 ns/op`, both `240 B/op, 9 allocs/op`) + +### runtime2 dispatch fast-hash pass: maphash upgrade for no-change gating + +- Replaced the byte-loop FNV implementation in `buildSnapshotDispatchFastHash(...)` with a process-seeded `maphash.Bytes(...)` path in `internal/runtime2/snapshot_dispatch_hash.go`. +- Kept the existing non-zero sentinel behavior (`0 -> 1`) and all call-site contracts intact. +- Updated benchmark/docs wording from `fnv` to generic `fast` prefilter terminology where the implementation now uses `maphash`. +- Updated `internal/runtime2/perf_snapshot_dispatch_fast_hash_compare_bench_test.go` so the legacy sub-bench preserves the previous buffered FNV path (`legacy_buffered_fnv1a`) while current uses streamed maphash (`current_streamed_maphash`). + +Validation: +- `go test ./internal/runtime2 -run "TestHandleHostRegionDispatchHash" -count=1` +- `go test ./internal/runtime2 -run ^$ -bench "Benchmark(BuildSnapshotDispatchFastHashCurrentVsLegacy|HandleHostRegionDispatchHashCurrentVsLegacy|HandleHostRegionSnapshotHashPrefilterCurrentVsLegacy)$" -benchmem -count=3` +- `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostWorkerRegionUpdateOrchestrationCurrentVsLegacy$" -benchmem -count=3` + +Benchmark snapshot (Windows/amd64, i7-12700): +- `BenchmarkBuildSnapshotDispatchFastHashCurrentVsLegacy/current_streamed_maphash`: `~933-1046 ns/op`, `104 B/op`, `3 allocs/op` +- `BenchmarkBuildSnapshotDispatchFastHashCurrentVsLegacy/legacy_buffered_fnv1a`: `~1422-1681 ns/op`, `104 B/op`, `3 allocs/op` +- `BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/stable_payload_current_digest_guard`: `~381-392 ns/op`, `0 B/op`, `0 allocs/op` +- `BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/no_change_current_fast_prefilter`: `~245-257 ns/op`, `0 B/op`, `0 allocs/op` + +### render-benchmark example 201 MT worker latency improvements + +Five latency improvements implemented across `examples/testing/render-benchmark/workers.go`, `examples/testing/render-benchmark/backgroundworker/main.go`, and `examples/testing/render-benchmark/shared/shared.go`. + +- **Progressive per-lane chunk delivery** — replaced the all-or-nothing `WaitGroup` barrier with per-lane partial delivery. Added `onPartialChunks func([]ChunkResult)` callback parameter to all six fan-out functions (`requestBenchmarkWorkerCoreChunks`, `requestBenchmarkWorkerContentChunks`, and both `ByBatch`/`ByChunk` variants). Each lane goroutine emits a `make+copy` snapshot and calls the callback immediately on completion. `handleBenchmarkWorkerPrepareEffect` wires `onPartialCoreLaneDone` / `onPartialContentLaneDone` closures that call `parseCoreChunkState.Set(...)` / `parseContentChunkState.Set(...)` per-lane under a stale-generation guard. + +- **Per-item generation early abort in background worker** — added two package-level `atomic.Uint64` counters (`getBenchmarkWorkerCoreLatestGeneration`, `getBenchmarkWorkerContentLatestGeneration`) to `backgroundworker/main.go`. Counters are written in `shouldBenchmarkWorkerDropStaleRequest` when a newer generation arrives and read every 8 items in `buildBenchmarkWorkerCoreChunkWithCache` / `buildBenchmarkWorkerContentChunkWithCache`. Also checks generation between chunks inside `buildBenchmarkWorkerCoreBatchWithCache` / `buildBenchmarkWorkerContentBatchWithCache`. Returns `HasStale: true` on abort; batch builders propagate stale early exits. + +- **Data-driven adaptive chunk count** — `buildBenchmarkWorkerAutoChunkCount` now reads `parseWorkerState.GetLastBatchMS` instead of ignoring it. Chunk target scales to `workerCount×1` when last batch < 3 ms (reduce IPC overhead), `workerCount×2` at 3–8 ms (original heuristic), and `workerCount×4` when > 8 ms (maximise progressive fanout against slow workers). + +- **Stronger dependency hash** — both `buildBenchmarkWorkerCoreItemsDependency` and `buildBenchmarkWorkerContentItemsDependency` replaced 4-point sample loops with a full pass over every item, reusing the existing `buildBenchmarkWorkerCoreItemDependency` / `buildBenchmarkWorkerContentItemDependency` per-item mixers. Both `hasBenchmarkWorkerCoreChunkCacheMatch` / `hasBenchmarkWorkerContentChunkCacheMatch` O(n) item-scan guards simplified to item-count-only checks; string comparisons on the main JS-thread hot path eliminated. + +- **Dirty-set delta sends** — added `GetDirtyItemIndexes []int` field (omitempty) to `BenchmarkWorkerCoreBatchChunkRequest` and `BenchmarkWorkerContentBatchChunkRequest` in `shared/shared.go`. Three new helpers: `buildBenchmarkWorkerCoreItemDirtyIndexes`, `buildBenchmarkWorkerContentItemDirtyIndexes`, `buildBenchmarkWorkerChunkLocalDirtyIndexes`. Client computes dirty indexes by comparing previous/current equal-length item slices and passes chunk-local slices into batch requests. Worker adds per-chunk result caches (`getBenchmarkWorkerCoreChunkResultByIndex`, `getBenchmarkWorkerContentChunkResultByIndex`) and a dirty-set fast path: when a previous chunk result and dirty indexes are both available, only dirty items are recomputed and XOR-merged into the previous result; clean items are copied without any cache-key allocation. + +- Benchmarks (Windows/amd64, i7-12700, `examples/testing/render-benchmark/shared`): + - `SnapshotCopyNilCallback`: `0.12 ns/op, 0 allocs` — nil-guard is zero-cost + - `SnapshotCopy4Chunks`: `~64 ns/op, 1 alloc (320 B)` + - `SnapshotCopy8Chunks`: `~118–137 ns/op, 1 alloc (704 B)` + - `SnapshotCopy16Chunks`: `~311–334 ns/op, 1 alloc (1408 B)` + - `BuildCoreChunkResult40Items`: `~1.25 ms/op` — snapshot overhead <0.01% of lane work + - `BuildCoreChunkResult240Items`: `~8 ms/op` — snapshot overhead <0.005% + +### runtime2 structured-clone snapshot transport header-only fast paths + +- Completed the next runtime2 transport todo in `internal/runtime2/structured_clone_snapshot_transport.go`: + - `BuildStructuredCloneSnapshotEnvelopeJSON(...)` now takes a direct header-only append path when both `props` and `sources` are absent. + - `ParseStructuredCloneSnapshotEnvelopeJSON(...)` now takes a header-only fast parser when payloads omit `props`/`sources`, while preserving full `json.Unmarshal` fallback for rich payloads. +- Added compare benchmark coverage: + - `internal/runtime2/perf_structured_clone_snapshot_transport_compare_bench_test.go` + - `BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy` (build-rich, build-header-only, parse-rich, parse-header-only). +- Validation: + - `go test ./internal/runtime2 -run "Test(BuildStructuredCloneSnapshotEnvelopeJSONRoundTrips|ParseStructuredCloneSnapshotEnvelopeJSONFailsMalformedEnvelope|ParseStructuredCloneSnapshotEnvelopeJSONDefaultsOptionalFields|ParseStructuredCloneSnapshotEnvelopeJSONRejectsMalformedJSON|ParseStructuredCloneSnapshotEnvelopeJSONRejectsNonObjectPayload|SelectSnapshotTransportTierPrefersBinary|BuildSnapshotTransportPayloadWithFallbackDowngradesOnBinaryEncodeFailure|ParseSnapshotTransportPayloadWithFallbackDowngradesOnBinaryDecodeFailure)" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkBuildStructuredCloneSnapshotEnvelopeJSON$" -benchmem -count=5` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy$" -benchmem -count=3` +- Benchmark snapshot (Windows/amd64, i7-12700): + - header-only build: `legacy ~182-208 ns/op, 128 B/op, 2 allocs/op` -> `current ~86-96 ns/op, 112 B/op, 1 alloc/op` + - header-only parse: `legacy ~669-944 ns/op, 288 B/op, 6 allocs/op` -> `current ~82-89 ns/op, 8 B/op, 1 alloc/op` + - rich paths stayed in-band: + - build: both around `~1.0-1.15 us/op`, `624 B/op`, `14 allocs/op` + - parse: current around `~2.40-2.55 us/op` with matching `1152 B/op`, `28 allocs/op`. + +### runtime2 host patch fallback parse benchmark coverage extension + +- Extended fallback parse benchmark coverage in `internal/runtime2/perf_host_patch_transport_parse_compare_bench_test.go` by adding `shared_buffer_fallback_structured` current-vs-legacy sub-bench (shared tier selected, no shared page, structured message payload fallback path). +- Validation: + - `go test ./internal/runtime2 -run "TestParseHostPatchPayloadWithFallback" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy$" -benchmem -count=5` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(ParseBinaryPatchPayload|GetSharedPatchReadPayload)$" -benchmem -count=5` +- Benchmark snapshot: + - `shared_buffer_fallback_structured` kept lower current-path allocation pressure (`legacy 952 B/op, 19 allocs/op` vs `current 888 B/op, 17 allocs/op`) with noisy ns/op on this host. + +### runtime2 worker render-input source normalization and cache reuse follow-up + +- Extended the `BuildWorkerRenderInput(...)` optimization pass in `internal/runtime2/worker_render_input_adapter.go`: + - replaced the mismatch normalization chain (`map keys -> NormalizeSourceIDs(...) -> clone`) with a single validated source-key extraction+sort pass (`buildWorkerRenderNormalizedSourceIDsFromSnapshot(...)`), + - removed the redundant post-normalization cached-source-ID clone on mismatch and now return normalized IDs directly as the next cache order. +- Added focused behavior coverage: + - `internal/runtime2/worker_render_input_adapter_test.go` with `TestBuildWorkerRenderInputRejectsInvalidSourceID`. +- Revised source-order compare benchmark to pin old/new behavior explicitly: + - `internal/runtime2/perf_worker_render_input_source_order_compare_bench_test.go`. +- Validation: + - `go test ./internal/runtime2 -run "Test(BuildWorkerRenderInputWithSourceOrderReusesCachedSourceIDs|BuildWorkerRenderInputWithSourceOrderRebuildsOnSourceSetChange|BuildWorkerRenderInputRejectsInvalidSourceID|HandleWorkerRegion|BuildWorkerRenderInput|BuildSnapshotEnvelope)" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy$" -benchmem -count=5` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleWorkerRegionUpdateSnapshotDrivenVsMetadataOnly$" -benchmem -count=5` +- Benchmark snapshot (Windows/amd64, i7-12700): + - source-order rebuild path: `legacy ~522-639 ns/op, 640 B/op, 4 allocs/op` -> `current ~438-497 ns/op, 384 B/op, 2 allocs/op`, + - source-order cached path: current/legacy both remain in-band at `~242-300 ns/op, 256 B/op, 1 alloc/op`, + - worker update benchmark on this host moved from pre-change `snapshot-driven ~3947-6056 ns/op, 5846-5847 B/op, 41 allocs/op` and `metadata-only ~4912-6430 ns/op, 5486 B/op, 37 allocs/op` to post-change `snapshot-driven ~2337-3310 ns/op, 3015 B/op, 25 allocs/op` and `metadata-only ~2319-2972 ns/op, 2654-2655 B/op, 21 allocs/op`. + +### runtime2 snapshot props shape-fingerprint cache in host update capture + +- Completed the next runtime2 perf todo by adding a second props-cache tier in `HandleHostRegionUpdateSnapshot(...)`: + - tier 1: existing immutable scalar token cache, + - tier 2: new flat `map[string]any` shape cache using key-count plus sorted-key hash and per-key scalar type markers. +- Runtime changes: + - `internal/runtime2/host_region_adapter.go` + - stores cached sorted keys and type markers for flat props, + - hot-path cache hit checks use O(n) map lookups against cached sorted keys/type markers (no per-hit key sorting), + - preserves full `ValidateSerializableProps(...)` fallback for non-flat or nested props. + - `internal/runtime2/spec.go` + - added shape-fingerprint builders and matcher helpers for flat scalar `map[string]any` props. +- Coverage additions: + - `internal/runtime2/spec_shape_fingerprint_test.go` + - `internal/runtime2/host_region_snapshot_capture_test.go` (`TestHandleHostRegionUpdateSnapshotPropsCacheInvalidatesOnTypeFlip`) + - `internal/runtime2/perf_host_region_props_shape_fingerprint_compare_bench_test.go` +- Validation: + - `go test internal/runtime2/registry.go internal/runtime2/spec.go internal/runtime2/spec_shape_fingerprint_test.go -run "TestBuildSerializablePropsFlatShapeFingerprint" -count=1` + - `go test internal/runtime2/host_region_snapshot_capture_test.go -run "TestHandleHostRegionUpdateSnapshot(PropsCacheInvalidatesOnInPlaceMutation|PropsCacheInvalidatesOnTypeFlip|CapturesPropsAndSources|ReusesSourceMapForStableVersionTuple|InvalidatesSourceMapReuseOnVersionChange|InvalidatesSourceMapReuseOnRemountEpoch)" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionUpdateSnapshot(CurrentVsLegacy|PropsShapeFingerprintCurrentVsLegacy)$" -benchmem -count=5` + - `go test internal/runtime2/host_region_pressure_bench_test.go -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$" -benchmem -count=5` +- Benchmark snapshot (Windows/amd64, i7-12700): + - wide flat stable props: + - current: `~525.9-750.1 ns/op`, `592 B/op`, `4 allocs/op` + - legacy: `~1345-1550 ns/op`, `1008 B/op`, `11 allocs/op` + - wide flat changed props (same key/type shape): + - current: `~574.5-689.5 ns/op`, `600 B/op`, `4 allocs/op` + - legacy: `~1258-1893 ns/op`, `1016 B/op`, `11 allocs/op` + - pressure benchmark remained in broad historical range with unchanged allocation profile: + - `~16.2-24.6 us/op`, `382-383 B/op`, `47 allocs/op`. + +### runtime2 source map ordered-key dispatch hashing todo closure + +- Closed the next runtime2 todo after verifying the source key-order optimization path is already active: + - `handleHostRegionDispatchHash(...)` passes canonical declared source IDs into `appendSnapshotDispatchEnvelopeWithSourceIDs(...)`, + - source hashing uses `appendSnapshotDispatchSourceMap(...)` + `appendSnapshotDispatchAnyMapWithOrderedKeys(...)`, + - when ordered source IDs fully cover the source map, dispatch hashing skips per-update generic map key extraction/sorting. +- Validation: + - `go test internal/runtime2/host_region_update_dispatch_test.go -run "TestHandleHostRegionUpdateDispatch" -count=1` + - `go test internal/runtime2/host_region_pressure_bench_test.go -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$" -benchmem -count=5` +- Result: + - ordered source-ID hash path confirmed active in code and tests, + - pressure benchmark remained in expected band with unchanged allocation profile (`~16.2-24.6 us/op`, `382-383 B/op`, `47 allocs/op`). + +### runtime2 dispatch coordinator-write batching todo closure + +- Closed the coordinator-write batching todo after verifying dispatch branches already use single coordinator write transactions: + - urgent changed dispatch path uses `StoreRegionSnapshotDispatchState(...)` for snapshot+dispatch version persistence in one lock-held write, + - no-change and deferred paths each use `SetRegionSnapshotState(...)` as one transaction write. +- Validation: + - `go test internal/runtime2/host_region_update_dispatch_test.go -run "TestHandleHostRegionUpdateDispatch" -count=1` + - `go test internal/runtime2/host_region_pressure_bench_test.go -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$" -benchmem -count=5` +- Result: + - no split snapshot/dispatched write helper pattern remains in dispatch branches, + - pressure benchmark allocation profile remained unchanged (`382-383 B/op`, `47 allocs/op`). + +### runtime2 allocation-reporting benchmark todo closure + +- Closed the `b.ReportAllocs()` benchmark todo after verifying both primary pressure benches already report allocations: + - `internal/runtime2/host_region_pressure_bench_test.go` (`BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`) + - `internal/runtime2/agent3_bench_test.go` (`BenchmarkHandleHostRegionUpdateDispatchLoop`) +- Validation: + - `rg -n "ReportAllocs\\(" internal/runtime2/host_region_pressure_bench_test.go internal/runtime2/agent3_bench_test.go` + - `go test internal/runtime2/host_region_pressure_bench_test.go -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$" -benchmem -count=5` +- Result: + - allocation reporting is active and current pressure runs keep reporting `383 B/op`, `47 allocs/op`. + +### runtime2 capability report lock-free reads and one-time detection memoization + +- Completed the capabilities memoization todo in `internal/runtime2/capabilities.go`: + - replaced lock-based capability reads with lock-free atomic reads (`atomic.Bool` + `atomic.Value`), + - memoized runtime capability detection once per process via `sync.Once` in `InitCapabilityReportFromRuntime()`. +- Added focused microbenchmark: + - `internal/runtime2/capabilities_bench_test.go` with `BenchmarkGetCapabilityReport`. +- Validation: + - `go test internal/runtime2/capabilities_test.go -run "Test(GetCapabilityReportDefaultsWithoutWorkerSupport|InitCapabilityReportStoresDetectedCapabilities|InitCapabilityReportFromRuntimeUsesDetectedSource)" -count=1` + - `go test internal/runtime2/capabilities_bench_test.go -run ^$ -bench "BenchmarkGetCapabilityReport$" -benchmem -count=5` +- Benchmark snapshot (Windows/amd64, i7-12700): + - `initialized-lock-free-read`: `~2.063-2.152 ns/op`, `0 B/op`, `0 allocs/op` + - `uninitialized-default-read`: `~1.644-1.987 ns/op`, `0 B/op`, `0 allocs/op`. + +### runtime2 coordinator trusted-ID mutation path for mounted host regions + +- Completed the next runtime2 perf todo by splitting coordinator mutable-entry reads into validated and trusted variants. +- Added trusted coordinator mutation helpers in `internal/runtime2/coordinator.go` for hot mounted-region operations: + - `handleCoordinatorCommitRegionTrusted(...)` + - `handleCoordinatorFallbackRegionTrusted(...)` + - `handleCoordinatorRestartRegionTrusted(...)` + - `handleCoordinatorSetRegionAttachedTrusted(...)` + - trusted stale counter increment helpers +- Updated host hot paths to use trusted helpers when the region ID is already mount-validated: + - `internal/runtime2/host_region_adapter.go` + - `internal/runtime2/host_control_dispatcher.go` +- Kept external coordinator API behavior unchanged by preserving `ParseRegionInstanceID(...)` checks in exported methods. +- Added focused compare benches in `internal/runtime2/perf_coordinator_get_update_compare_bench_test.go`: + - `BenchmarkCoordinatorGetMutableEntryValidatedVsTrusted` + - `BenchmarkCoordinatorCommitRegionValidatedVsTrusted` +- Validation: + - `go test ./internal/runtime2 -run "Test(SetRegionSnapshotState|SetRegionAttachedStoresAttachedState|HandleHostRegionMount|HandleHostRegionUpdateSnapshot)" -count=1` + - `go test ./internal/runtime2 -run "Test(CommitRegion|FallbackRegion|RestartRegion|SetRegionAttached|IncrementRegionDroppedStalePatchCount|IncrementRegionIgnoredStaleDiagnosticCount|IncrementRegionRepairRemountCount|HandleHostControlEnvelopeDispatchesPatchReady|HandleHostControlEnvelopeDispatchesDiagnostic|HandleHostControlEnvelopeDispatchesRestart|HandleHostRegionPatchReadyStaleBeforeRepairFloorIncrementsDroppedCounter|HandleHostRegionWorkerOutputOlderVersionIncrementsDroppedCounter)" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkCoordinator(GetMutableEntryValidatedVsTrusted|CommitRegionValidatedVsTrusted)$" -benchmem -count=5` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$" -benchmem -count=5` +- Benchmark snapshot (Windows/amd64, i7-12700): + - mutable entry read: validated `~33.8-40.3 ns/op` vs trusted `~25.7-29.2 ns/op` (`0 allocs` both), + - commit write: validated `~77.1-95.3 ns/op` vs trusted `~69.9-82.1 ns/op` (`0 allocs` both), + - pressure bench remained in-band at `~15.9-17.6 us/op`, `383 B/op`, `47 allocs/op`. + +### runtime2 props layout evaluation: map iteration vs sorted key/value slice scan + +- Closed the next runtime2 todo as an explicit evaluation pass before changing snapshot envelope semantics. +- Added `internal/runtime2/perf_snapshot_dispatch_prop_layout_compare_bench_test.go` with: + - `BenchmarkSnapshotDispatchPropLayoutCurrentVsEntries` + - current path: `appendSnapshotDispatchAnyMap(...)` (map iterate + sort each call) + - candidate path: pre-sorted `[]buildSnapshotDispatchMapEntry` sequential scan (`appendSnapshotDispatchAnyMapEntries(...)`) +- Validation: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkSnapshotDispatchPropLayoutCurrentVsEntries$" -benchmem -count=5` +- Benchmark snapshot (Windows/amd64, i7-12700): + - current map path: `~679.6-699.4 ns/op`, `104 B/op`, `3 allocs/op` + - candidate slice scan: `~49.8-63.8 ns/op`, `0 B/op`, `0 allocs/op` +- Outcome: + - sequential key/value slices show clear hot-path potential for steady prop shapes, + - runtime integration is deferred to a follow-up safe-cache pass because existing decode and test paths still intentionally treat `SnapshotEnvelope.Props` as `map[string]any`. + +### runtime2 snapshot hash FNV-64a prefilter, dispatch hash FNV-64a, and priority-skip refactor + +Three hot-path optimizations applied to `internal/runtime2/host_region_adapter.go`. + +**1. Snapshot hash FNV-64a prefilter (`handleHostRegionSnapshotHash`)** +- Added two new struct fields: `storeHostRegionSnapshotFastHash uint64` and `storeHostRegionSnapshotHashScratch []byte`. +- On each call, `appendSnapshotDispatchEnvelope` now produces canonical bytes (InputVersion normalized to 1), then `buildSnapshotDispatchFastHash` (FNV-64a) runs over the result. +- If FNV-64a matches the stored fast hash, SHA-256 is skipped entirely and the stored digest is returned directly. +- All four state-reset paths (mount, dispose, structural remount, repair remount) now also clear the new fast-hash fields. + +**2. Dispatch hash FNV-64a (`handleHostRegionDispatchHash`)** +- Replaced the `sha256.Sum256` in the payload-hash path with `buildSnapshotDispatchFastHash` (FNV-64a). +- SHA-256 struct fields (`storeHostRegionDispatchHash`, `storeHostRegionDispatchBytes`) are now cleared on every hash computation, removing stale state. +- The version-vector gate still exits early (no hashing) on source-version mismatch; the FNV-64a path runs only when the version vector matches and a payload check is needed. + +**3. Dispatch priority skip (`HandleHostRegionUpdateDispatch`)** +- Added unexported `handleHostRegionUpdateDispatchWithKnownPriority` containing the full dispatch body. +- `HandleHostRegionUpdateDispatch` now routes directly to the inner function with `HostRegionDispatchPriorityUrgent`, skipping the `ParseHostRegionDispatchPriority` call on every urgent invocation. +- `HandleHostRegionUpdateDispatchWithTransition` also routes directly. +- `HandleHostRegionUpdateDispatchWithPriority` still validates the externally-supplied priority before delegating. + +**New microbenchmark** +- Added `BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy` in + `internal/runtime2/perf_host_region_snapshot_hash_prefilter_compare_bench_test.go`. +- Covers no-change and changed sub-cases against a self-contained legacy state struct that always runs SHA-256. + +**Validation** +- `go test ./internal/runtime2 -run "TestHandleHostRegionSnapshotFingerprint|TestHandleHostRegionUpdateDispatch|TestHandleHostRegionDispatchHash|TestHandleHostRegionUpdateSnapshot" -count=1` +- `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy|BenchmarkHandleHostRegionSnapshotFingerprint|BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy|BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred|BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers" -benchmem -count=5` + +**Benchmark snapshot (Windows/amd64, i7-12700)** + +Snapshot fingerprint no-change hot path (primary target): +- `BenchmarkHandleHostRegionSnapshotFingerprint/no-change`: `~746-1000 ns/op`, `456 B/op`, `8 allocs/op` → `~189-258 ns/op`, `0 B/op`, `0 allocs/op` **(~3-4x speedup, zero allocs)** + +Snapshot hash prefilter compare (new benchmark): +- `no_change_legacy_sha_always`: `~1602-1983 ns/op`, `1906 B/op`, `20 allocs/op` +- `no_change_current_fnv_prefilter`: `~349-409 ns/op`, `0 B/op`, `0 allocs/op` **(~4-5x speedup, zero allocs)** +- `changed_legacy_sha_always`: `~2491-3691 ns/op`, `3597 B/op`, `31 allocs/op` +- `changed_current_fnv_prefilter`: `~2727-4058 ns/op`, `2588 B/op`, `25 allocs/op` (comparable latency, 6 fewer allocs) + +Deferred dispatch no-change path: +- `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `~371-430 ns/op`, `0 allocs` → `~278-320 ns/op`, `0 allocs` **(~14-25% speedup)** +- Follow-up re-run confirms: `no-change ~275-297 ns/op`, `changed ~472-632 ns/op`, `changed-reused-spec ~379-431 ns/op`, all `0 allocs/op` on no-change and reused-spec paths. + +Dispatch hash compare: +- `changed_payloads_current_version_vector_gate`: `~12-16 ns/op`, `0 allocs` (version-vector source-version mismatch exits fast; unchanged) +- `stable_payload_current_digest_guard`: `~897-1061 ns/op`, `104 B/op`, `3 allocs` (FNV-64a digest comparison — previous 5 ns was from an InputVersion fast-exit overridden by correctness test) + +Pressure benchmark: +- `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: `~16724-20561 ns/op`, `382 B/op`, `47 allocs/op` (within prior noise band) + +### runtime2 coordinator pointer-entry todo closure + +- Closed the coordinator-map layout todo after verifying pointer-entry storage is already active in `internal/runtime2/coordinator.go` (`storeEntries map[RegionInstanceID]*CoordinatorEntry`). +- Validation: + - `go test ./internal/runtime2 -run "Test(SetRegionSnapshotState|UpdateRegionAndGetEntry|StoreRegionSnapshotAndDispatchedVersion|HandleHostRegionUpdateSnapshot)" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkCoordinatorDispatchTransactionCurrentVsLegacy$" -benchmem -count=5` +- Microbench snapshot: + - `current_single_snapshot_and_dispatch`: `~40.96-44.42 ns/op` + - `legacy_split_snapshot_and_dispatch`: `~64.34-81.14 ns/op` + - both paths remained `0 B/op`, `0 allocs/op`. + +### runtime2 snapshot hash prefilter todo closure + +- Closed the pending snapshot-hash prefilter todo after verifying the FNV-64a + SHA path is already implemented in `handleHostRegionSnapshotHash(...)`. +- Validation run: + - `go test ./internal/runtime2 -run "TestHandleHostRegionUpdateSnapshot" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegion(UpdateSnapshot|ManyHotRegionsBoundedWorkers)$" -benchmem -count=5` +- Current benchmark baseline from this validation: + - `BenchmarkHandleHostRegionUpdateSnapshot`: `~316-428 ns/op`, `592 B/op`, `4 allocs/op` + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: `~16.8-21.6 us/op` (with emitted p50/p95/p99 metrics). + +### runtime2 serializable-props fast path: typed scalar containers + +- Completed the next runtime2 perf todo in `internal/runtime2/spec.go` by keeping common typed scalar containers on the non-reflective path: + - added direct fast exits for typed scalar slices like `[]int` and `[]string`, + - added typed `map[string]scalar` validation with the existing ref and DOM-marker key guards, + - skipped redundant recursive checks for primitive leaves inside `[]any` and `map[string]any`. +- Added focused coverage in: + - `internal/runtime2/spec_test.go` + - `internal/runtime2/perf_serializable_props_compare_bench_test.go` +- Validation: + - `go test ./internal/runtime2 -run "Test(HandleHostRegionUpdateSnapshotPropsCacheInvalidatesOnInPlaceMutation|ValidateSerializablePropsAcceptsTypedScalarContainers|ValidateSerializablePropsRejectsTypedScalarMapRefMarker)" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkValidateSerializablePropsCurrentVsLegacy$" -benchmem -count=3` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$" -benchmem -count=5` +- Benchmark snapshot: + - typed string map: `~269.5-313.3 ns/op`, `128 B/op`, `8 allocs/op` legacy -> `~69.7-74.0 ns/op`, `0 B/op`, `0 allocs/op` current, + - typed int slice: `~58.5-88.7 ns/op`, `24 B/op`, `1 alloc/op` legacy -> `~18.5-24.0 ns/op`, `24 B/op`, `1 alloc/op` current, + - widened host pressure benchmark stayed in the expected `~17.5-21.0 us/op`, `382 B/op`, `47 allocs/op` band. + +### runtime2 dispatch no-change: enforced two-tier vector + fast-hash check + +- Completed the next runtime2 perf todo for dispatch no-change checks by enforcing two tiers in `handleHostRegionDispatchHash(...)`: + - tier 1: version-vector mismatch still short-circuits as changed, + - tier 2: exact version-vector matches now run canonical payload fast-hash comparison before returning no-change. +- Added focused regression coverage in `internal/runtime2/snapshot_dispatch_hash_test.go` proving payload mutations with unchanged version-vector fields are treated as changed. +- Validation: + - `go test ./internal/runtime2 -run "TestHandleHostRegionUpdateDispatch" -count=1` + - `go test ./internal/runtime2 -run "TestHandleHostRegionDispatchHash.*" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(HandleHostRegionDispatchHashCurrentVsLegacy|HandleHostRegionManyHotRegionsBoundedWorkers)$" -benchmem -count=5` +- Benchmark snapshot: + - changed-payload current path stayed low-latency (`~11.0-12.9 ns/op`, `0 allocs/op`), + - exact-vector stable repeats now pay fast-hash verification (`~1.0-1.3 us/op`, `104 B/op`, `3 allocs/op`) versus prior direct vector short-circuit (`~4.7 ns/op`), + - pressure benchmark stayed in broad prior range (`~17.2-26.4 us/op`). + +### runtime2 pressure profiling: unified cpu/mutex/block/mem capture + +- Completed the runtime2 profiling-workflow TODO for pressure benchmarks by standardizing one run that captures all key profile artifacts together. +- Validation flow used: + - `go test -c -o ./bin/runtime2.test.exe ./internal/runtime2` + - `./bin/runtime2.test.exe -test.run=^$ -test.bench=BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$ -test.benchtime=10s -test.cpuprofile=./bin/runtime2.hot.cpu.pprof -test.mutexprofile=./bin/runtime2.hot.mutex.pprof -test.blockprofile=./bin/runtime2.hot.block.pprof -test.memprofile=./bin/runtime2.hot.mem.pprof` +- Artifacts confirmed from one invocation: + - `bin/runtime2.hot.cpu.pprof` + - `bin/runtime2.hot.mutex.pprof` + - `bin/runtime2.hot.block.pprof` + - `bin/runtime2.hot.mem.pprof` +- Note: profile-enabled runs intentionally distort benchmark means (`ns/op`, `B/op`, `allocs/op`) and are diagnostics-only, not regression baselines. + +### runtime2 benchmark telemetry: p50/p95/p99 tail metrics + +- Completed the runtime2 benchmarking TODO for tail-latency sampling in pressure and update-dispatch loops: + - added p50/p95/p99 sample reporting to `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers` (`internal/runtime2/host_region_pressure_bench_test.go`), + - added a focused update-dispatch loop benchmark with p50/p95/p99 metrics in `agent3_bench_test.go` (`BenchmarkHandleHostRegionUpdateDispatchLoop`). +- Implementation notes: + - benchmarks now collect span-based latency samples during hot loops and emit percentile metrics via `b.ReportMetric(...)`, + - span sampling avoids Windows timer-resolution collapse on very short per-iteration timings. +- Validation commands: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers$" -benchmem -count=20` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionUpdateDispatchLoop$" -benchmem -count=5` +- Benchmark snapshots (Windows/amd64, i7-12700): + - pressure benchmark now emits `dispatch-batch-p50/p95/p99` around `~23.5-23.8 us`, `~31.2-47.4 us`, `~39.3-48.3 us` respectively, while mean stayed near prior range (`~19.6-25.7 us/op` before instrumentation pass vs `~18.8-25.0 us/op` after), + - new agent3 update-dispatch loop baseline: `p50 ~740-749 ns`, `p95 ~1109-1207 ns`, `p99 ~1126-1379 ns` with mean `~788-874 ns/op`. + +### runtime2 dispatch hash: version-vector no-change gate + +- Completed the runtime2 dispatch-hash TODO for a pre-hash version-vector gate in `handleHostRegionDispatchHash(...)`: + - gate now checks `(rendererID, epoch, ordered sourceVersions[], inputVersion)` before any digest work, + - exact vector matches short-circuit directly as no-change, + - source-version tuple mismatches still invalidate digest cache immediately, + - input-version-only churn still falls through to digest comparison so existing no-change behavior remains intact. +- Runtime2 files updated: + - `internal/runtime2/host_region_adapter.go` + - `internal/runtime2/host_control_dispatcher.go` + - `internal/runtime2/snapshot_dispatch_hash_test.go` + - `internal/runtime2/perf_host_region_dispatch_hash_compare_bench_test.go` + - `docs/MULTITHREADED_RUNTIME_TODO.md` +- Focused validation: + - `go test ./internal/runtime2 -run "TestHandleHostRegionUpdateDispatch.*NoChange" -count=1` + - `go test ./internal/runtime2 -run "TestHandleHostRegionDispatchHash.*" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(HandleHostRegionDispatchHashCurrentVsLegacy|HandleHostRegionManyHotRegionsBoundedWorkers)$" -benchmem -count=5` +- Benchmark samples (Windows/amd64, i7-12700): + - `BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/stable_payload_current_*`: `~724-885 ns/op` -> `~4.8-5.1 ns/op`, `0 B/op`, `0 allocs/op` + - `BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/changed_payloads_current_*`: `~5.6-7.1 ns/op` -> `~11.1-11.9 ns/op`, `0 B/op`, `0 allocs/op` + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: `~20.6-25.3 us/op` -> `~19.6-25.7 us/op` (allocation profile unchanged at `382 B/op`, `47 allocs/op`) + +### runtime2 patch parse or commit pass: close three TODO perf items + +- Completed three runtime2 performance backlog TODOs in patch parse/commit paths: + - removed eager empty attr-map allocation by making insert-node `GetAttrByKey` lazy in `parseBuildRegionDOMNodeFromPatchRecord(...)` (`internal/runtime2/patch_stream.go`), + - removed duplicate keyed-move scan work by adding `ParsePatchStreamTransactionWithKeyedMoveHint(...)` and wiring host commit to pass precomputed `hasPatchKeyedMoveOp` (`internal/runtime2/patch_stream.go`, `internal/runtime2/host_region_adapter.go`), + - collapsed keyed-move lookup extraction to one pass on host commit by using `BuildRegionDOMPatchLookupMaps(...)` when keyed moves are present (`internal/runtime2/host_region_adapter.go`). +- Updated TODO status in `docs/MULTITHREADED_RUNTIME_TODO.md`: + - `#695` lazy insert attr-map allocation, + - `#697` one-pass keyed-move lookup extraction, + - `#699` keyed-move scan removal via host hint. +- Focused validation: + - `go test ./internal/runtime2 -run "TestParsePatchStreamTransaction|TestHandleHostRegionPatchCommit" -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "Benchmark(ParsePatchStreamTransaction|CommitRegionPatchTransaction)$" -benchmem -count=1` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkCommitRegionPatchTransaction$" -benchmem -count=1` +- Quick benchmark samples from this pass (Windows/amd64, i7-12700): + - `BenchmarkParsePatchStreamTransaction`: `180.7 ns/op -> 156.3 ns/op`, + - `BenchmarkCommitRegionPatchTransaction`: `3332 ns/op -> 2870-2909 ns/op`. + +### runtime2 patch-stream hotspot pass: fewer sibling scans and lower string-collection churn + +- Completed three runtime2 performance-backlog items in `internal/runtime2/patch_stream.go`: + - pre-sized patch-string accumulation via `buildPatchStringCapacityFromPatchOps(...)` before building patch string tables, + - removed unnecessary `parseFilterCanonicalExistingOrder(...)` allocations when there is no insert/remove structural delta, + - removed repeated sibling-index scans in insert ordering by reusing one `parseBuildCanonicalSiblingIndexCache(...)` lookup cache in the insert sort comparator. +- Added a small worker control-dispatch hot-path cleanup in `internal/runtime2/worker_control_dispatcher.go`: + - rejects unsupported kinds before full envelope validation, + - reuses decoded region/renderer/snapshot fields across dispatch branches, + - keeps explicit mount/update snapshot guards. +- Focused validation: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkBuildCanonicalPatchStream$" -benchmem -count=5` + - `go test ./internal/runtime2 -run "TestHandleWorkerControlEnvelope" -count=1` +- Latest patch-stream benchmark sample after this pass (Windows/amd64, i7-12700): + - `BenchmarkBuildCanonicalPatchStream`: `4.335-4.521 us/op`, `6019-6020 B/op`, `46 allocs/op`. + +### runtime2 control-plane perf pass: control JSON + host/worker dispatch + +- Completed three runtime2 performance backlog items in the control plane: + - reduced control envelope JSON build/parse overhead (`internal/runtime2/control.go`, `internal/runtime2/diagnostic_redaction.go`), + - reduced host-side control-plane dispatch overhead (`internal/runtime2/host_control_dispatcher.go`, `internal/runtime2/host_region_adapter.go`), + - reduced worker-side control-plane dispatch overhead (`internal/runtime2/worker_control_dispatcher.go`, `internal/runtime2/worker_region_runtime.go`). +- Control envelope path changes: + - kept hot-path validation on direct kind switches and protocol/tier helpers, + - moved diagnostic redaction to in-place mutation and run it after validation in JSON build/parse so invalid envelopes skip redaction work. +- Host dispatch changes: + - added a focused host-control preflight for host-supported kinds, + - removed duplicate mounted-state checks in host dispatch branches, + - routed diagnostic dispatch into an internal validated/redacted adapter path to avoid duplicate envelope validation and diagnostic kind re-parse. +- Worker dispatch changes: + - rejects unsupported control kinds before full envelope validation, + - reuses decoded region/renderer/snapshot fields across branches, + - mount/update dispatch now uses internal runtime paths that skip duplicate snapshot-envelope validation already guaranteed by control-envelope validation. +- Updated runtime2 todo tracking notes/checkpoints for the completed items in `docs/MULTITHREADED_RUNTIME_TODO.md`. +- Focused validation commands: + - `go test ./internal/runtime2 -run "Test(ParseControlEnvelopeJSON|BuildControlEnvelopeJSON|ValidateControlEnvelope)" -count=1` + - `go test ./internal/runtime2 -run "TestHandleHostControlEnvelope" -count=1` + - `go test ./internal/runtime2 -run "TestHandleWorkerControlEnvelope" -count=1` + - `go test ./internal/runtime2 -count=1` + +### runtime2 shard-session perf follow-up: queue/drop and patch-ready polling + +- Completed two runtime2 shard-session performance backlog items in `internal/runtime2/shard_session.go`: + - reduced queue-lock/payload-copy overhead in the inbound queue and send path, + - reduced patch-ready pairing poll overhead while waiting for paired patch payloads. +- Inbound queue and send-path changes: + - queue-limit overflow handling now compacts in place via `copy(...)` and overwrites the tail slot, avoiding append-based re-slice churn on bounded queue drops, + - `HandleShardSessionSendPayload(...)` now posts the validated payload directly instead of creating one extra per-send clone first. +- Patch-ready polling changes: + - `HandleShardSessionReceivePatchReadyWithPayload(...)` now uses a cheap control-envelope marker probe (`"protocol_version"` + `"kind"` on object-shaped payloads) before attempting full `ParseControlEnvelopeJSON(...)` while pending payload pairing is active. + - This keeps behavior unchanged while avoiding repeated full JSON control parses for ordinary non-control patch payloads. +- Focused validation commands: + - `go test ./internal/runtime2 -run "Test(BuildShardSessionWithQueueLimitCapsInboundPayloadQueue|BuildShardSessionConcurrentInboundAndReceiveStaysStable|HandleShardSessionSendPayloadUsesPort|HandleShardSessionReceivePayloadDrainClearsQueueState)$" -count=1` + - `go test ./internal/runtime2 -run "TestHandleShardSession(ReceivePatchReadyWithPayloadWaitsForDelayedPayload|ReceivePatchReadyWithPayloadRejectsNextControlBeforePayload|SendAndReceivePatchReadyWithPayload)$" -count=1` + - `go test ./internal/runtime2 -run "Test(ParseControlEnvelopeJSON|BuildControlEnvelopeJSON|ValidateControlEnvelope|HandleHostControlEnvelope|BuildShardSessionWithQueueLimitCapsInboundPayloadQueue|BuildShardSessionConcurrentInboundAndReceiveStaysStable|HandleShardSessionSendPayloadUsesPort|HandleShardSessionReceivePayloadDrainClearsQueueState|HandleShardSessionReceivePatchReadyWithPayloadWaitsForDelayedPayload|HandleShardSessionReceivePatchReadyWithPayloadRejectsNextControlBeforePayload|HandleShardSessionSendAndReceivePatchReadyWithPayload)$" -count=1` + +### runtime2 Core Filter commit path: in-place sibling removal for heavy filter churn + +- Optimized `parseFilterChildNodeIDs(...)` in `internal/runtime2/dom_commit.go` to remove one child ID in place (`find index -> shift tail -> truncate`) instead of allocating a new filtered slice on each remove. +- This targets the core runtime commit path exercised by Core Filter-style structural churn where many siblings are removed under the same parent. +- Added focused micro-benchmark coverage in `internal/runtime2/dom_commit_filter_bench_test.go`: + - `BenchmarkCommitRegionRemoveNodeFilterHeavy` + - models repeated sibling removals across `120`, `240`, and `480` child lists. +- Benchmark command: + - `go test ./internal/runtime2 -run ^$ -bench BenchmarkCommitRegionRemoveNodeFilterHeavy -benchmem -count 5` +- Before/after means (Windows/amd64, i7-12700): + - `siblings-120`: `16.96 us/op -> 6.40 us/op` (`2.65x` faster), `54400 B/op -> 0`, `80 allocs/op -> 0` + - `siblings-240`: `52.97 us/op -> 14.00 us/op` (`3.78x` faster), `218625 B/op -> 0`, `160 allocs/op -> 0` + - `siblings-480`: `180.00 us/op -> 40.78 us/op` (`4.41x` faster), `878595 B/op -> 0`, `320 allocs/op -> 0` +- Focused behavior validation: + - `go test ./internal/runtime2 -run "TestCommitRegionRemoveNode|TestCommitRegionPatchTransaction"` + +### Example 201 runtime2 hook-grid render investigation (hot-path diagnosis) + +- Reviewed the current Example 201 `hooks-render` path and confirmed runtime2 does not offload hook execution to workers for this scenario: + - `buildBenchmarkRuntime3Node(...)` routes `hooks` to `renderBenchmarkRuntime3HookCell(...)` (`examples/testing/render-benchmark/main.go`), which still executes per-cell hook loops on the main thread and wraps cells with `ui.ParallelRegion(...)`. + - `handleBenchmarkWorkerPrepareEffect(...)` (`examples/testing/render-benchmark/workers.go`) only prepares `core`/`content` payloads and exits early for `hooks`. +- Re-checked latest benchmark artifact `bin/test-results/example-201-browser-benchmark/browser-benchmark-report-rt2-1-4.json`: + - `hooks-render` DOM-ready mean: `runtime2-workers1=11.7 ms`, `runtime2-workers4=14.957 ms`, `runtime1=7.5 ms`, `react=1.186 ms`. + - Mutation counts in the same run: `runtime2=120`, `runtime1=80`, `react=40`. +- Conclusion from this pass: runtime2 hook-grid slowness is currently dominated by main-thread hook work plus region orchestration/wrapper overhead, so increasing worker count does not improve this benchmark shape. +- No runtime behavior change was shipped in this diagnosis-only pass; this entry documents the measured bottleneck and rationale for a future hooks-specific fast path. + +### Example 201 runtime2 core append: chunked core regions + html/shorthand core-row render path + +- Updated Example 201 runtime2 core rendering to preserve chunk boundaries instead of flattening worker-prepared core chunks into one primary region: + - `buildBenchmarkRuntime3Node(...)` now renders one `ui.ParallelRegion(...)` per prepared core chunk via `buildBenchmarkRuntime3CoreRegionNodes(...)` (`examples/testing/render-benchmark/main.go`). + - This keeps unchanged chunk regions stable during append-heavy updates and reduces whole-list reconciliation pressure in the benchmark shell. +- Adopted `html/shorthand` (dot-import) for the runtime2 core row renderer in `examples/testing/render-benchmark/main.go`: + - `renderBenchmarkRuntime3CoreRegion(...)` now uses `Div(...)`, `Class(...)`, `Data(...)`, `Text(...)`, and `WithKey(...)` for core row node construction. +- Validation commands: + - `$env:GOOS='js'; $env:GOARCH='wasm'; go build ./examples/testing/render-benchmark` + - `go test -tags playwrightgo ./test/playwrightgo/examples -run TestExample201BrowserBenchmarkReportRuntime2OneAndFourWorkers -count=1 -v` +- Latest report artifact: + - `bin/test-results/example-201-browser-benchmark/browser-benchmark-report-rt2-1-4.md` + - `Core Append` sample (`DOM Ready Mean`): `Runtime 2 (1 Worker)=12.771 ms`, `Runtime 2 (4 Workers)=12.086 ms`. + +### Example 201 runtime2 prepare-cache fast path for repeated benchmark payloads + +- Added dependency-keyed prepared-chunk memoization to the runtime2 benchmark prepare path in `examples/testing/render-benchmark`: + - new per-app refs in `renderBenchmarkApp(...)` for cached core/content chunk batches (`main.go`), + - cache-hit fast paths in `handleBenchmarkWorkerPrepareEffect(...)` that hydrate chunk state directly and skip worker request round-trips (`workers.go`), + - cache store/read helpers with slice cloning to keep stable ownership when reusing cached chunk results (`workers.go`). +- This primarily targets repeated identical payloads in Example 201 iteration loops (not first-seen payloads), especially `Core Stress Update`. +- Validation command: + - `go test -tags playwrightgo ./test/playwrightgo/examples -run TestExample201BrowserBenchmarkReportRuntime2OneAndFourWorkers -v` +- Reported delta on the same `rt2-1-4` route (`browser-benchmark-report-rt2-1-4.md`): + - `Core Stress Update`: + - `Runtime 2 (1 Worker)`: `38.886 ms -> 6.471 ms` (`-83.4%`, `6.01x` faster) + - `Runtime 2 (4 Workers)`: `44.471 ms -> 6.714 ms` (`-84.9%`, `6.62x` faster) + +### runtime2 NormalizeSourceIDs: replace map dedup with sort+dedup-in-place + +- Replaced `make(map[string]bool, n)` dedup in `NormalizeSourceIDs(...)` (`internal/runtime2/spec.go`) with single-pass sort + in-place consecutive-duplicate removal on the output `[]string`, eliminating one map allocation per call. +- Benchmark deltas (`BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`, 12th Gen Intel i7-12700, Windows/amd64, `-benchmem -count=5`): + - **4 → 2 allocs/op** (−50%), **440 → 344 B/op** (−22%) +- `NormalizeSourceIDs` behavior is unchanged: duplicate IDs are still removed, output is canonical-sorted. + +### runtime2 appendBinarySnapshotBody: named-function defer eliminates closure struct alloc + +- Extracted the pool-cleanup body from the anonymous `defer func() { ... }()` in `appendBinarySnapshotBody(...)` into a named top-level `releaseSnapshotBodySourceIDsCache(parseCache *buildBinarySourceIDsCache)` in `internal/runtime2/binary_snapshot_body.go`. +- Changed the defer to `defer releaseSnapshotBodySourceIDsCache(parseSourceIDsCache)` — a non-closure defer the Go compiler can open-code without a heap-allocated closure struct. + + + +- Added a dedicated dispatch-only snapshot hash path: + - `internal/runtime2/snapshot_dispatch_hash.go` (`buildSnapshotDispatchHashInto(...)` and `appendSnapshotDispatch*` helpers), + - canonical markers + sorted map-key encoding + non-finite number guardrails, + - adapter-local scratch-byte reuse (`storeHostRegionDispatchBytes`) to avoid per-dispatch payload churn. +- Wired host update dispatch to this path in `internal/runtime2/host_region_adapter.go` via `handleHostRegionDispatchHash(...)`. +- Kept public snapshot-fingerprint behavior unchanged (`HandleHostRegionSnapshotFingerprint(...)` still uses the JSON hash path). +- Added focused coverage in `internal/runtime2/snapshot_dispatch_hash_test.go` for: + - input-version-insensitive dispatch hashing, + - map-order canonical stability, + - non-finite number rejection. +- Focused microbench command: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred|BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers|BenchmarkHandleHostRegionSnapshotFingerprint" -benchmem -count=5` +- Before/after deltas from this pass (Windows/amd64, i7-12700): + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: + - `750.7-860.3 ns/op, 200 B/op, 6 allocs/op` -> `340.7-393.7 ns/op, 0 B/op, 0 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: + - `1216-1313 ns/op, 705 B/op, 12 allocs/op` -> `526.5-645.8 ns/op, 440 B/op, 4 allocs/op`. + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: + - `52239-68395 ns/op, 10002-10003 B/op, 335 allocs/op` -> `27899-30333 ns/op, 382 B/op, 47 allocs/op`. + +### runtime2 dispatch-hash map fast path: bypass pooled sort for 0/1/2-key maps + +- Optimized `internal/runtime2/snapshot_dispatch_hash.go` tiny-map encoding: + - `appendSnapshotDispatchAnyMap(...)` now uses dedicated 0/1/2-key fast paths before the pooled `sort.Strings(...)` path. + - `appendSnapshotDispatchReflectMap(...)` mirrors the same 0/1/2-key fast paths for reflect-driven values. +- Added helper coverage and bug guardrails: + - fixed the empty-string-key edge case in the 2-key fast path. + - added `TestBuildSnapshotDispatchHashCanonicalPairWithEmptyKey` in `internal/runtime2/snapshot_dispatch_hash_test.go`. +- Expanded deferred-dispatch hotspot benchmarking with `changed-reused-spec` in `internal/runtime2/perf_hotspot_bench_test.go` so runtime cost can be measured without per-iteration spec allocation churn. +- Microbench command: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred|BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers|BenchmarkHandleHostRegionSnapshotFingerprint" -benchmem -count=5` +- Delta from immediately before this fast-path pass (Windows/amd64, i7-12700): + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: + - `343.3-417.7 ns/op, 0 B/op, 0 allocs/op` -> `304.2-325.2 ns/op, 0 B/op, 0 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: + - `563.7-708.6 ns/op, 344 B/op, 3 allocs/op` -> `508.0-523.7 ns/op, 344 B/op, 2 allocs/op`. + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: + - `27742-29828 ns/op, 382 B/op, 47 allocs/op` -> `25935-26553 ns/op, 381-382 B/op, 47 allocs/op`. + - New `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed-reused-spec`: + - `380.1-392.0 ns/op, 7 B/op, 0 allocs/op`. +- Final validation rerun for this pass: + - `go test ./internal/runtime2 -count=1` passed. + - Final bench sample remained in the same range: + - `no-change`: `304.2-325.2 ns/op` + - `changed`: `508.0-523.7 ns/op` + - `many-hot-regions`: `25935-26553 ns/op` + +### runtime2 rollback snapshot clone: skip empty attr-map allocations + +- Updated `parseCloneRegionNodeMap(...)` (`internal/runtime2/dom_commit.go`) to avoid allocating `map[string]string{}` for cloned nodes when `GetAttrByKey` is empty. +- The rollback snapshot path now only allocates/copies attr maps when a source node actually has attributes, eliminating unneeded per-node map allocations during patch-transaction commit flows. +- Microbench command: + - `go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction)$" -benchmem -count 12` +- Benchstat (commit-focused) (`bin/runtime2_dupwork_pass7_before_utf8.txt` vs `bin/runtime2_dupwork_pass7_after_utf8.txt`, Windows/amd64, i7-12700): + - `BenchmarkCommitRegionPatchTransaction`: `3.575 us/op -> 3.287 us/op` (`-8.07%`, `p=0.006`) + - allocs/op: `49 -> 47` (`-4.08%`) + - B/op: unchanged (`5.734 KiB/op`) +- Focused validation: + - `go test ./internal/runtime2 -run "CommitRegionPatchTransaction|PatchStream|RollsBackPartialState|InvalidMidStreamTriggersFallback" -count=1` + +### Example 201 browser benchmark: heavier non-capped RT2 scaling cases + +- Expanded the active Example 201 scenario matrix with heavier browser-visible work: + - `Core Stress Update` for 240-row targeted updates + - `Core Append` for 240 -> 340 row structural churn + - `Core Filter` for 240 -> 80 row structural churn +- Stabilized the RT2 core benchmark path by flattening worker-prepared core chunks into one public runtime2 core region before commit, so chunk-sibling ordering does not distort the browser result. +- Tightened the RT2 prepare effect inputs and improved benchmark timeout diagnostics with framework, worker, action, and row-order context. +- Kept prepend/reverse/sort out of the active comparison route for now because the current public runtime2 shell is not yet reliable enough to benchmark those ordering semantics fairly. +- Regenerated Example 201 Playwright reports after the change: + - `browser-benchmark-report.md` + - `browser-benchmark-report-rt2-1-4.md` + +### runtime2 decode hot path: ASCII trim-check fast path + +- Added `parseRuntimeHasTrimmedNonWhitespaceText(...)` in `internal/runtime2/text_whitespace.go`: + - fast ASCII scan for common non-whitespace checks, + - Unicode-safe fallback to `strings.TrimSpace(...)` when non-ASCII bytes are present. +- Replaced decode-path `strings.TrimSpace(...) != ""` checks with the helper: + - `ParseRenderNodeRecord(...)` (`internal/runtime2/render_node_record.go`) + - canonical prop-key decode in `parseBuildCanonicalPropByKeyFromRaw(...)` (`internal/runtime2/render_ir.go`) +- Added targeted A/B microbench coverage in `internal/runtime2/perf_trim_check_compare_bench_test.go`: + - `BenchmarkParseRuntimeHasTrimmedNonWhitespaceTextCurrentVsLegacy` +- Microbench commands: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkParseRuntimeHasTrimmedNonWhitespaceTextCurrentVsLegacy$" -benchmem -benchtime=800ms -count=6` + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkParseCanonicalRenderTree$" -benchmem -benchtime=600ms -count=6` +- Bench artifacts and deltas (Windows/amd64, i7-12700): + - Component bench (`bin/runtime2_optpass8_trimcheck_component_compare.txt`): + - `current` median `2.7815 ns/op` vs `legacy` median `4.4655 ns/op` (`-37.71%`). + - Parse bench (`bin/runtime2_optpass8_before_parse_trimcheck.txt` vs `bin/runtime2_optpass8_after_parse_trimcheck_rerun.txt`): + - `BenchmarkParseCanonicalRenderTree` median `22918.5 ns/op -> 11912.5 ns/op` (`-48.02%`), allocs unchanged at `16 allocs/op`. + +### runtime2 keyed-sibling dedupe: probe-table fast path and pooled map fallback + +- Optimized `parseRenderNodeSiblingKeys(...)` in `internal/runtime2/render_node_table.go`: + - `<=64` keyed siblings now use a fixed-size stack probe table (open addressing), avoiding pairwise O(n^2) scans. + - large keyed sibling sets keep hash-first validation, with pooled maps (`sync.Pool`) for fallback collision promotion state. +- Added regression/coverage updates: + - `TestParseRenderNodeTableDuplicateKeysBeyondPairwiseLimitFail` + - `TestParseRenderNodeTableHashCollisionDifferentKeyTextPass` + - benchmark compare harness `BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy` (`internal/runtime2/perf_sibling_keys_compare_bench_test.go`). +- Microbench command: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy$" -benchmem -benchtime=500ms -count=4` +- Bench artifacts and deltas (`bin/runtime2_optpass5_sibling_compare_final.txt` vs `bin/runtime2_optpass6_after_probe_pool_sibling_compare.txt`): + - `medium-64/current`: median `2628.5 ns/op -> 362.4 ns/op` (`-86.21%`). + - `large-512/current`: median `14725 ns/op -> 12894 ns/op` (`-12.43%`). + - `large-512/current` memory profile: `41000 B/op, 3 allocs/op -> 0 B/op, 0 allocs/op`. + +### runtime2 patch transaction parse: pre-size op slice to remove append growth work + +- Updated `ParsePatchStreamTransaction(...)` (`internal/runtime2/patch_stream.go`) to pre-size `RegionPatchTransaction.GetOps` with `cap=len(parseRaw.GetOps)` instead of growing from zero capacity during per-op appends. +- This removes duplicated append-growth work (reallocate+copy) for every parsed patch transaction, especially on commit paths where all parsed ops are always appended. +- Microbench command: + - `go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction)$" -benchmem -count 10` +- Benchstat (`bin/runtime2_dupwork_pass5_before_utf8.txt` vs `bin/runtime2_dupwork_pass5_after_utf8.txt`, Windows/amd64, i7-12700): + - `BenchmarkParsePatchStreamTransaction`: `357.8 ns/op -> 271.0 ns/op` (`-24.27%`), `672 -> 448 B/op`, `2 -> 1 allocs/op`. + - `BenchmarkCommitRegionPatchTransaction`: `6.381 us/op -> 3.979 us/op` (`-37.64%`), `5.953 KiB/op -> 5.734 KiB/op`, `50 -> 49 allocs/op`. + +### runtime2 patch parse: skip redundant canonical string-table rebuild + +- Updated `ParsePatchStreamTransaction(...)` (`internal/runtime2/patch_stream.go`) to avoid rebuilding the string table when `GetStringTable` is already canonical. +- Added `parseHasCanonicalStringTableSortedUnique(...)` and a fast path that: + - validates canonical ordering/uniqueness in one linear pass, + - reuses the incoming string-table slice directly, + - falls back to `ParseRenderStringTable(...)` for non-canonical inputs to preserve correctness and validation behavior. +- Microbench command: + - `go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkBuildCanonicalPatchStream|BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction)$" -benchmem -count 8` +- Benchstat comparison (filtered to affected parse/commit paths): + - `ParsePatchStreamTransaction`: `312.2 ns/op -> 245.8 ns/op` (`-21.27%`), `720 -> 672 B/op`, `3 -> 2 allocs/op`. + - `CommitRegionPatchTransaction`: `3.613 us/op -> 3.716 us/op` (within noise), `6.000 KiB/op -> 5.953 KiB/op`, `51 -> 50 allocs/op`. + +### runtime2 benchmark refresh and keyed-sibling validation review + +- Re-ran focused runtime2 microbenchmarks against both the current tree and a clean `HEAD` worktree (`../GoWebComponents-baseline`) using: + - `go test ./internal/runtime2 -run ^$ -bench "BenchmarkParseCanonicalRenderTree|BenchmarkBuildPatchStreamIdentity|BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred|BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers|BenchmarkHandleHostRegionUpdateSnapshot|BenchmarkBuildAndParseBinarySnapshotEnvelope|BenchmarkParseBinarySnapshotEnvelopeSourceHeavy|BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy" -benchmem -count=3` +- Kept the keyed-sibling split strategy in `internal/runtime2/render_node_table.go`: bounded probe-table checks for smaller keyed sibling sets, map-backed checks for larger sets. +- Representative before/after ranges from this run set (Windows/amd64, i7-12700): + - `BenchmarkParseCanonicalRenderTree`: about `39.7-48.3 us/op, 62384 B/op, 92 allocs/op` -> `14.1-20.5 us/op, 55616 B/op, 16 allocs/op`. + - `BenchmarkBuildAndParseBinarySnapshotEnvelope/build`: about `6.1-7.2 us/op, 3248 B/op, 87 allocs/op` -> `1.1-1.4 us/op, 528 B/op, 2 allocs/op`. + - `BenchmarkBuildAndParseBinarySnapshotEnvelope/parse`: about `4.5-5.5 us/op, 2426 B/op, 61 allocs/op` -> `2.4-2.7 us/op, 1976 B/op, 36 allocs/op`. + - `BenchmarkParseBinarySnapshotEnvelopeSourceHeavy`: about `7.7-8.5 us/op, 4003 B/op, 102 allocs/op` -> `4.0-4.2 us/op, 3360 B/op, 68 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: about `1.9-2.0 us/op, 352 B/op, 11 allocs/op` -> `0.95-1.06 us/op, 200 B/op, 6 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: about `3.0-3.1 us/op, 968 B/op, 23 allocs/op` -> `1.3-1.5 us/op, 705 B/op, 12 allocs/op`. + - `BenchmarkHandleHostRegionUpdateSnapshot`: about `2.3-2.5 us/op, 1616 B/op, 16 allocs/op` -> `1.0-1.1 us/op, 1184 B/op, 8 allocs/op`. + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: about `160-175 us/op, 43946-46631 B/op, 718 allocs/op` -> `61-85 us/op, 10000-10003 B/op, 335 allocs/op`. + +### runtime2 snapshot body + envelope: three-alloc chain collapsed to single allocation + +- Added `appendBinarySnapshotBody(dst []byte, parseEnvelope SnapshotEnvelope) ([]byte, error)` in `internal/runtime2/binary_snapshot_body.go` as an internal accumulator that encodes props, source ID table, and source values directly into a caller-provided buffer using write-back length placeholders and `binary.LittleEndian.PutUint32` fixups; `BuildBinarySnapshotBody` delegates to it with a fresh buffer. +- Replaced `buildBinaryPropsValueWithoutValidation(...)` (intermediate `[]byte` + append) with a 4-byte write-back placeholder + inline `buildBinarySourceValueInto(dst, ...)`, eliminating one per-call allocation in the props section. +- Added `storeBinarySourceIDsPool` (`sync.Pool` of `*buildBinarySourceIDsCache`) and `buildBinaryCanonicalSourceIDsInto(parseDst []string, ...)` accumulator; `appendBinarySnapshotBody` gets a cache from the pool, resets to `[:0]`, fills source IDs, then defers a clear-and-return, eliminating the per-call `make([]string, ...)` allocation during source ID encoding. +- Added `writeBinaryEnvelopeHeaderAt(dst []byte, kind, payloadLength, checksum uint32)` to `internal/runtime2/binary_header.go`: writes the 16-byte envelope header at `dst[0:]` in-place via `binary.LittleEndian.PutUint16/32` without `append`. +- Changed `BuildBinarySnapshotEnvelope` to pre-reserve `binaryEnvelopeHeaderSize` bytes at the start of one buffer, call `appendBinarySnapshotBody` to fill the body, then `writeBinaryEnvelopeHeaderAt` to seal — eliminating the separate header slice and second allocation. +- Benchmark deltas (`BenchmarkBuildAndParseBinarySnapshotEnvelope/build`, 12th Gen Intel i7-12700, Windows/amd64, `-benchmem -count=5`): **7 → 2 allocs/op, 1073 → 528 B/op** (−71% allocs, −51% bytes). + +### runtime2 mount + update + snapshot parse: fuse envelope builds and pool parse-side source-ID slices + +- **`BuildBinaryMountEnvelope`** fused to single allocation via `appendBinarySnapshotBody`: + - Replaced `BuildBinarySnapshotBody(...)` call (intermediate `[]byte`) + append into body with inline `appendBinarySnapshotBody(parsePayload, snapshot)` + write-back length placeholder; pre-reserves `binaryEnvelopeHeaderSize` bytes and uses `writeBinaryEnvelopeHeaderAt` at the end. + - Added `BenchmarkBuildAndParseBinaryMountEnvelope` (`internal/runtime2/binary_snapshot_bench_test.go`). + - Benchmark (`/build`, 12th Gen Intel i7-12700, `-benchmem -count=5`): **3 allocs/op, 705 B/op** + +- **`BuildBinaryUpdateEnvelope`** fused identically: + - Snapshot body encoded inline with write-back length; header pre-reserved; `ValidateSnapshotEnvelope` made explicit at call site. + - Benchmark (`/build`, `-benchmem -count=5`): **7 → 1 allocs/op, 736 → 192 B/op** (−86% allocs, −74% bytes) + +- **`ParseBinarySnapshotBody`** parse-side source-ID slice pooled: + - Added `parseBinarySourceIDTableInto(parseDst []string, parsePayload []byte)` accumulator in `internal/runtime2/binary_source_id_table.go`; `ParseBinarySourceIDTable` refactored to call it. + - `ParseBinarySnapshotBody` now gets a `buildBinarySourceIDsCache` from `storeBinarySourceIDsPool`, passes its slice to `parseBinarySourceIDTableInto`, feeds it to `parseBinarySourceValuesSection`, then clears string refs and returns to pool. + - Benchmark (`BenchmarkBuildAndParseBinarySnapshotEnvelope/parse`, `-benchmem -count=5`): **36 → 35 allocs/op, 1976 → 1945 B/op** + +- **`appendBinarySnapshotBody`** defer updated to clear source-ID string refs before returning cache to `storeBinarySourceIDsPool`, consistent with `storeBinarySourceMapKeyBuffer` pattern. + +- Added `appendBinarySnapshotBody(dst []byte, parseEnvelope SnapshotEnvelope)` — internal accumulator variant of `BuildBinarySnapshotBody` that encodes directly into a provided buffer: + - **Props write-back length**: replaced the `buildBinaryPropsValueWithoutValidation(...)` call (returning a temp `[]byte`) + copy with a 4-byte write-back placeholder + inline `buildBinarySourceValueInto(dst, parseEnvelope.Props)`, eliminating one `[]byte` allocation per call. + - **Pooled source ID slice**: added `storeBinarySourceIDsPool` (`sync.Pool` of `*buildBinarySourceIDsCache` containing `[]string`) and `buildBinaryCanonicalSourceIDsInto(parseDst []string, ...)` accumulator; `appendBinarySnapshotBody` gets from pool, resets to `[:0]`, fills, `defer`-returns — eliminating the per-call `make([]string, ...)` allocation. +- Changed `BuildBinarySnapshotEnvelope` to pre-reserve `binaryEnvelopeHeaderSize` bytes at the start of a single allocation, call `appendBinarySnapshotBody` to encode the body directly after, then write the header in-place via new `writeBinaryEnvelopeHeaderAt(dst, kind, payloadLen, checksum)` — eliminating the second `[]byte` allocation for the assembled envelope. +- Added `writeBinaryEnvelopeHeaderAt` to `internal/runtime2/binary_header.go`: writes magic, version, kind, section count, payload length, and checksum into `dst[0:16]` using `binary.LittleEndian.PutUint16/32` without `append`. +- `BuildBinarySnapshotBody` retains its public signature and now calls `appendBinarySnapshotBody` with a fresh buffer sized from region ID length + source count estimate. +- Benchmark deltas (`BenchmarkBuildAndParseBinarySnapshotEnvelope/build`, 12th Gen Intel i7-12700, Windows/amd64, `-benchmem -count=5`): + - allocs/op: **7 → 2** (−5 allocs per snapshot envelope build) + - B/op: **1073 → 528** (−545 bytes per call, −51%) + +- Replaced `buildBinaryLengthPrefixedString(...)` call in `BuildBinaryUpdateEnvelope(...)` (`internal/runtime2/binary_mount_transport.go`) with `appendBinaryLengthPrefixedString(parseBody, ...)` direct into the body buffer, matching the same fix applied to `BuildBinaryMountEnvelope` in the prior entry. Capacity pre-computed as `2+len(RegionInstanceID)+8+4+len(snapshotBody)` to avoid resize. +- Added `BenchmarkBuildAndParseBinaryUpdateEnvelope` to `internal/runtime2/binary_snapshot_bench_test.go` to cover this path going forward. +- Benchmark (`BenchmarkBuildAndParseBinaryUpdateEnvelope/build`, 12th Gen Intel i7-12700, Windows/amd64, `-benchmem -count=5`, after fix): + - allocs/op: **8 → 7** (−1 alloc per update envelope build) + - B/op: **736** (−1 small region-payload allocation) + +### runtime2 source-values section and mount envelope: write-back length eliminates intermediate allocations + +- Replaced `BuildBinarySourceValue(...)` call inside `appendBinarySourceValuesSection(...)` (`internal/runtime2/binary_snapshot_body.go`) with the write-back length pattern — reserve a 4-byte length placeholder, call `buildBinarySourceValueInto(parsePayload, parseSourceValue)` to encode directly into the parent buffer, then `binary.LittleEndian.PutUint32(parsePayload[lenOff:], itemLen)` — eliminating one temporary `[]byte` allocation per source value. +- Replaced the three intermediate `buildBinaryLengthPrefixedString`/`buildBinarySourceIDTableFromNormalized` allocations in `BuildBinaryMountEnvelope(...)` (`internal/runtime2/binary_mount_transport.go`) with direct-append variants: + - `parseRegionPayload` → `appendBinaryLengthPrefixedString(parseBody, ...)` directly into the body buffer + - `parseRendererPayload` → `appendBinaryLengthPrefixedString(parseBody, ...)` directly into the body buffer + - `parseSourceIDTablePayload` → write-back length + `appendBinarySourceIDTableFromNormalized(parseBody, ...)` directly into the body buffer, with `setBinaryUint32At` fixup + - Body capacity pre-computed from known field sizes (`2+len(RegionInstanceID)+2+len(RendererID)+4+sourceTableSize+4+len(snapshotBody)`) to avoid resize +- Benchmark deltas (`BenchmarkBuildAndParseBinarySnapshotEnvelope/build`, 12th Gen Intel i7-12700, Windows/amd64, `-benchmem -count=5`): + - allocs/op: **11 → 7** (−4 allocs per snapshot envelope build) + - B/op: **1329 → 1073** (−256 bytes per call) + + + +- Replaced the `make([]byte, binaryEnvelopeHeaderSize)` + PutUint* pattern in `BuildBinaryEnvelopeHeader(...)` (`internal/runtime2/binary_header.go`) with a new private `appendBinaryEnvelopeHeader(dst []byte, ...) ([]byte, error)` helper that appends all 16 header bytes directly into an existing slice using `append`, `binary.LittleEndian.AppendUint16`, and `binary.LittleEndian.AppendUint32`. +- The public `BuildBinaryEnvelopeHeader(...)` API is unchanged; it delegates to `appendBinaryEnvelopeHeader(make([]byte, 0, 16), ...)` so external callers continue to work without modification. +- Updated all three internal transport build functions to use the single-allocation pattern — `make([]byte, 0, binaryEnvelopeHeaderSize+len(body))`, then `appendBinaryEnvelopeHeader` into that buffer, then `append(payload, body...)` — eliminating the separate 16-byte header slice and the second `make` + copy that the callers previously used: + - `BuildBinarySnapshotEnvelope(...)` (`internal/runtime2/binary_snapshot_transport.go`) + - `BuildBinaryMountEnvelope(...)` (`internal/runtime2/binary_mount_transport.go`) + - `BuildBinaryUpdateEnvelope(...)` (`internal/runtime2/binary_mount_transport.go`) +- Benchmark deltas (`BenchmarkBuildAndParseBinarySnapshotEnvelope/build`, 12th Gen Intel i7-12700, Windows/amd64, `-benchmem -count=5`): + - allocs/op: **12 → 11** (−1 alloc per call) + - B/op: **1345 → 1329** (−16 bytes per call) + + + +- Replaced all intermediate `[]byte` allocations in `BuildBinarySourceValue(...)` and its internal helpers (`internal/runtime2/binary_source_value.go`) with a single accumulator-buffer strategy using `buildBinarySourceValueInto(dst []byte, ...)` that appends all encoded bytes directly into the caller's buffer. +- Eliminated `buildBinarySourceNumberPayload(...)` (was `make([]byte, 9)` per numeric value) and `buildBinarySourceStringPayload(...)` (was `make([]byte, 5+len)` per string) by inlining `append(dst, kind)` + `binary.LittleEndian.AppendUint64/32` into the type-switch cases. +- Eliminated `bool` and `nil` heap allocations (`[]byte{binarySourceValueKindNil}`, etc.) by replacing with `append(dst, kind)` in all fast-path and reflect-path branches. +- Replaced `buildBinarySourceAnyListPayload(...)` and `buildBinarySourceAnyMapPayload(...)` with `buildBinarySourceAnyListInto(...)` and `buildBinarySourceAnyMapInto(...)` that use the write-back length pattern: reserve a 4-byte slot, encode the item directly into `dst`, then `binary.LittleEndian.PutUint32(dst[lenOff:], itemLen)` — eliminating one temporary allocation and one copy per list or map item. +- Applied the same write-back pattern to the reflect-path helpers: `buildBinarySourceValueReflectInto(...)`, `buildBinarySourceListInto(...)`, `buildBinarySourceMapInto(...)`, and `buildBinarySourceStructInto(...)`. +- Added `setBinaryUint32At(parsePayload []byte, parseOffset int, parseValue uint32)` to `internal/runtime2/binary_append.go` as a named helper for the write-back length fixup step, keeping the in-place `PutUint32` pattern consistent with the rest of the `appendBinary*` surface. +- Public API `BuildBinarySourceValue(...)` is unchanged; it now calls `buildBinarySourceValueInto(make([]byte, 0, 32), value)` so callers remain unaffected. +- Benchmark deltas (12th Gen Intel i7-12700, Windows/amd64, `go test ./internal/runtime2/... -run=^$ -bench="BenchmarkBuildBinarySourceValueAnyMapFastPath|BenchmarkBuildAndParseBinarySnapshotEnvelope" -benchmem -count=5`): + - `BenchmarkBuildBinarySourceValueAnyMapFastPath`: **4 allocs/op, 480 B/op** (nested map+list payload; prior state had ~52 allocs for an equivalent shape). + - `BenchmarkBuildAndParseBinarySnapshotEnvelope/build`: `87 allocs/op, 3248 B/op → 12 allocs/op, 1345 B/op` (**−86% allocs, −59% bytes**). + + + +### runtime2 hot-path allocation reduction (render IR, patch stream, binary encoding) + +- Extended Example 201 browser benchmarking with a second RT2-only stress route (`subjectSet=runtime2-scaling&runtime2WorkScale=12`) so worker-count scaling is reported separately from the mixed-framework one-frame paint view; the generated Markdown report now includes an `RT2 Worker Scaling Stress` section with worker-batch, DOM-ready, and paint-proxy columns for `1,2,4,8` workers. + +- Replaced the post-build BFS depth-assignment pass in `ParseCanonicalRenderTree(...)` (`internal/runtime2/render_ir.go`) with a single depth write per child during the initial child-wiring scan, eliminating the BFS queue allocation and all N read-modify-write 120-byte struct copies through the node map. +- Added `parseDepthByRecordIndex []int` auxiliary slice computed inline during the child-wiring pass so depth is available at node-state construction time; removed the separate `parseQueue` allocation and the post-loop. +- Replaced intermediate uniqueness-set `map[string]struct{}` in `BuildRenderStringTable(...)` (`internal/runtime2/render_string_table.go`) with sort + in-place dedup, saving one map allocation per call. +- Switched all three `appendBinaryUint*` helpers in `internal/runtime2/binary_append.go` to delegate to `binary.LittleEndian.AppendUint16/32/64`, which the compiler can lower without the intermediate stack-allocated `[N]byte` temporaries. +- Inlined FNV-64a in `parseHashCanonicalString(...)` (`internal/runtime2/render_ir.go`) using constant offset `14695981039346656037` and prime `1099511628211`, eliminating the `hash.Hash64` interface allocation and the `[]byte` string copy per call; removed the `hash/fnv` import from the file. +- Replaced `fmt.Sprintf("idx:%d", parseChildIndex)` in `parseAssignCanonicalNodeID(...)` with `strconv.AppendInt` into a stack `[32]byte` buffer and single-concatenation path building, eliminating one `fmt` format-parse + reflection call per non-keyed child node. +- Pre-sized the `buildRawValueByKey` map in `parseBuildCanonicalProps(...)` with `len(parseMapValue)` as a lower-bound capacity to avoid rehashing for typical 3–8 key host-element payloads. +- Allocated a single flat `buildChildIDPool []uint64` backing store in `ParseCanonicalRenderTree(...)` for all child ID lists, sub-sliced per parent, eliminating approximately one `make([]uint64, n)` per non-leaf node in the canonical tree. +- Benchmark deltas from `go test ./internal/runtime2/... -run ^$ -bench . -benchmem -count=3` (12th Gen Intel i7-12700, Windows/amd64): + - `BenchmarkParseCanonicalRenderTree`: `59648 ns/op, 62384 B/op, 92 allocs/op → 27651 ns/op, 55616 B/op, 16 allocs/op` (**−54% time, −83% allocs**). + - `BenchmarkBuildCanonicalRenderIR`: `4129 ns/op, 3250 B/op, 44 allocs/op → 3319 ns/op, 2978 B/op, 39 allocs/op` (−20% time, −11% allocs). + - `BenchmarkBuildCanonicalPatchStream`: allocs flat at 47–48/op; bytes reduced from 6100 to 6036 B/op; time stable within noise band. + - `BenchmarkBuildAndParseBinarySnapshotEnvelope/parse`: `~4346 ns/op → ~2861 ns/op` (−34%). + - `BenchmarkBuildPatchStreamIdentity/small`: `4 → 3 allocs/op`, `160 → 152 B/op`. + - `BenchmarkBuildPatchStreamIdentity/large-keyed-rotate`: `4 → 3 allocs/op`, `160 → 152 B/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `1360 ns/op, 9 allocs/op → 930 ns/op, 5 allocs/op` (−31% time, −44% allocs). + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: `2119 ns/op, 19 allocs/op → 1550 ns/op, 11 allocs/op` (−27% time, −42% allocs). + - `BenchmarkHandleHostRegionSnapshotFingerprint/changed`: `2280 ns/op, 16 allocs/op → 1190 ns/op, 12 allocs/op` (−48% time, −25% allocs). + +### Example 200 runtime2 worker tracing and rerender guard hardening + +- Expanded `examples/200-runtime2-status` with an explicit worker-offload diagnostics path: the 8-worker Go WASM fleet now runs deterministic CPU-bound probe workloads and reports per-worker iterations, compute duration, and digest fingerprints in both panel metrics and console logs. +- Added per-probe trace IDs across main and worker request logs so pooled-worker request correlation is unambiguous during debugging, even when worker-local request counters overlap. +- Added a render-trace panel in Example 200 that records app/region/inspector/fleet/workbench render deltas, renders a compact trend graph, and classifies rerenders as owner-driven, background async updates, or suspicious leak-like churn. +- Reduced worker-fleet UI churn by avoiding unnecessary loading-phase state flips and moving high-frequency worker metrics bookkeeping to ref-backed state, so example-level rerender pressure is easier to reason about while preserving telemetry fidelity. +- Added lazy worker-fleet boot and explicit telemetry-refresh behavior in Example 200 so the 8-worker pool stays in standby at owner count `0`, avoids cold-start churn until needed, and does not force background app-shell rerenders while probe snapshots stream in. +- Removed ref-write feedback from Example 200 render counting (`trackRuntime2StatusRenderCount(...)`) so tracing can no longer accidentally contribute to rerender pressure; repeated Playwright runtime runs stayed stable with `app-label-before=1` and no idle drift. +- Added example-boot reset guards (`resetRuntime2StatusRenderTraceStore(...)` and `resetRuntime2StatusWorkerTraceCounter(...)`) so repeated runtime2-status sessions start with fresh counters even under hot-reload-like workflows. +- Strengthened Example 200 Playwright rerender leak checks: the burst path now runs 8 increments and asserts idle stability for app, owner-panel, and workbench labels after both single-update and burst-update windows. + +### Example 200 worker fanout dispatch optimization and guardrails + +- Replaced Example 200 request dispatch from `interop.WorkerPool` arbitration to one dedicated worker-handle lane per probe in `examples/200-runtime2-status/workers.go`, so each batch now fans out directly to all 8 workers with less queue/admission coordination overhead on the main wasm runtime. +- Added explicit fleet-size mismatch guards and warn/error logging in the fanout path (`requestRuntime2StatusWorkerFleet(...)`, refresh guard, close path) so bad worker topology or stale batch conditions fail fast with actionable diagnostics instead of silent partial work. +- Collapsed per-batch metrics folding into one pass (`buildRuntime2StatusWorkerBatchStats(...)`) to reduce repeated result-slice scans. +- Reduced high-frequency worker log overhead in `examples/200-runtime2-status/backgroundworker/main.go` by removing per-message/per-request info logs while keeping required `probe complete` lines and clearer warn/error signals for unknown/decode-failure paths. +- Added dispatch microbench coverage in `interop/worker_fanout_bench_test.go` (`BenchmarkRequestWorkerDecodedFanoutDispatch`) with direct-lane vs pooled fanout sub-benchmarks. +- Focused fanout microbench sample (`go test ./interop -run ^$ -bench BenchmarkRequestWorkerDecodedFanoutDispatch -benchmem -count=5`, Windows/amd64, i7-12700): + - `direct-lanes` median: `25697 ns/op`, `3379 B/op`, `83 allocs/op`. + - `worker-pool` median: `30022 ns/op`, `3395 B/op`, `83 allocs/op`. + - Direct-lane dispatch reduced median fanout latency by about `14.41%` in this harness. + +### Runtime and runtime2 scheduler/transport hardening + +- Fixed reactive subscription movement during fiber cloning and keyed/non-keyed reconciliation so region-scoped atom subscribers move from stale fibers to live fibers without duplicate or leaked registrations. +- Hardened subscriber scheduling to prefer granular updates under fine-grained ancestors, map stale subscribers back to live alternates when possible, and ignore detached stale subscribers once a mounted tree exists. +- Added bounded guardrails and coverage for runtime2 patch-stream and DOM-commit operation volume, plus keyed-move sibling-count limits to fail fast before runaway diff/commit work. +- Added shard-session concurrency and ordering hardening: mutex-protected queue access, stale-port inbound rejection, queue-overflow warning throttling, delayed patch-ready payload handling, and contextual payload-send errors. +- Reworked `interop.WorkerPool` replacement flow to use slot-based worker ownership, asynchronous repair, close-time repair cancellation, and surfaced replacement failure context on later requests. +- Extended `ui.ParallelRegionSpec` with `SchedulerShardIDs` so apps can declare custom shard pools and remount regions when shard topology changes. +- Optimized runtime2 prop-serializability validation with a fast success path (`isSerializableValueFast(...)`) and `MapRange` iteration so normal serializable props avoid expensive path-building while unsupported shapes still produce detailed failure errors. +- Added wasm regression coverage for refresh-only `RenderInto(...)` updates with sibling `ui.ParallelRegion(...)` shells to ensure shell DOM nodes are reused in place and no child-list churn operations are emitted. +- Added runtime2 hotspot benchmarks for canonical tree parse, patch identity hashing, and deferred host-region dispatch paths, plus render-node sibling-key validation and snapshot fingerprint hash helper tuning. +- Revised `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers` to precompute region IDs/specs and reuse per-region props maps so benchmark output reflects runtime2 dispatch behavior rather than harness-only `fmt.Sprintf` and transient map allocations. +- Added focused runtime2 benchmark coverage in `internal/runtime2/snapshot_hash_bench_test.go` for snapshot identity (`GetSnapshotFingerprintHash(...)` vs `GetSnapshotFingerprint(...)`) and serializable-props validation fast-path behavior (valid fast path vs invalid fallback path). +- Optimized runtime2 host snapshot/update dispatch hot paths by removing redundant envelope validation work on already-normalized internal paths and by using trusted snapshot-hash helpers inside adapter-internal no-change checks. +- Added scheduler update-job coalescing for queued same-region updates at the same cancel generation, plus `TestHandleSchedulerUpdateCoalescesQueuedRegionUpdates` coverage to lock in the queue-depth contract. +- Re-validated snapshot fingerprint hashing under runtime2 hot-path pressure and kept the simpler `json.Marshal(...)` + `sha256.Sum256(...)` path in `internal/runtime2/snapshot.go` after an A/B check showed lower allocation counts than the streaming-hasher variant for the dispatch-heavy benches. +- Reduced runtime2 binary snapshot transport overhead in `internal/runtime2/binary_snapshot_body.go`, `internal/runtime2/binary_source_value.go`, `internal/runtime2/binary_source_id_table.go`, and `internal/runtime2/binary_offset.go` by removing duplicate props validation during body encode, adding non-reflect `[]any`/`map[string]any` source-value fast paths, replacing parse-time source-ID re-normalization with direct canonical validation, removing per-parse string-concat field labels, replacing value-typed `sync.Pool` key-buffer entries with pointer-backed cache entries to avoid interface boxing allocations, and appending source-id/source-values sections directly into the final snapshot buffer with in-place length backfill. +- Runtime2 binary snapshot microbench deltas from `go test ./internal/runtime2 -run ^$ -bench "BenchmarkBuildAndParseBinarySnapshotEnvelope" -benchmem`: + - `BenchmarkBuildAndParseBinarySnapshotEnvelope/build`: `2928 B/op -> 1625 B/op`, `67 -> 29 allocs/op`. + - `BenchmarkBuildAndParseBinarySnapshotEnvelope/parse`: `2266 B/op -> 1976 B/op`, `51 -> 36 allocs/op`. +- Added focused guard benchmarks for the new binary transport hot paths in `internal/runtime2/binary_source_value_bench_test.go`: + - `BenchmarkBuildBinarySourceValueAnyMapFastPath` + - `BenchmarkParseBinarySourceIDTableCanonical` +- Runtime2 hash-path A/B microbench deltas from `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers|BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred|BenchmarkHandleHostRegionSnapshotFingerprint" -benchmem`: + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: about `335 -> 287 allocs/op` (`~10.0 KB/op -> ~11.9 KB/op`). + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `6 -> 5 allocs/op` (`200 B/op -> 256 B/op`). + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: `12 -> 11 allocs/op` (`705 B/op -> 776 B/op`). +- Runtime2 focused bench deltas after these changes (same host machine, `go test ./internal/runtime2 -run ^$ -bench ... -benchmem`): + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: about `671 -> 575 allocs/op` and `~34 KB/op -> ~19 KB/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `13 -> 11 allocs/op` and `424 B/op -> 392 B/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: `25 -> 21 allocs/op` and `1024 B/op -> 960 B/op`. +- Reduced canonical tree parse overhead in `internal/runtime2/render_node_table.go` by pre-sizing node-record storage, switching child-span overlap ownership tracking from a map to a slice, and avoiding keyed-sibling hash-map setup when sibling sets contain zero or one keyed child. +- Added no-validation internal helpers for snapshot envelope/hash hot paths in `internal/runtime2/snapshot.go` and updated host no-change dispatch fingerprint handling in `internal/runtime2/host_region_adapter.go` to reuse cached digest state on unchanged payloads while preserving public validation contracts. +- Tightened runtime2 host snapshot capture again by reusing prevalidated source snapshots when building update envelopes and by skipping coordinator source-ID rewrites when the mounted source list is unchanged. +- Focused runtime2 snapshot-capture deltas from `go test ./internal/runtime2 -run ^$ -bench "BenchmarkHandleHostRegionUpdateSnapshot|BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred|BenchmarkHandleHostRegionSnapshotFingerprint" -benchmem`: + - `BenchmarkHandleHostRegionUpdateSnapshot`: `1021 ns/op, 1552 B/op, 12 allocs/op -> 749 ns/op, 1184 B/op, 8 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `985 ns/op, 240 B/op, 22 allocs/op -> 789 ns/op, 256 B/op, 5 allocs/op`. + - `BenchmarkHandleHostRegionSnapshotFingerprint/no-change`: `630 ns/op, 240 B/op, 22 allocs/op -> 562 ns/op, 256 B/op, 5 allocs/op`. +- Cleared host snapshot hash cache state alongside fingerprint-string resets during control restart handling in `internal/runtime2/host_control_dispatcher.go` so restart/remount flows cannot reuse stale no-change detection state. +- Reduced transient allocations in runtime2 identity and binary framing paths by switching patch identity formatting to `strconv.FormatUint(...)` and replacing string-based magic checks with byte-wise comparisons in `internal/runtime2/binary_patch_transport.go`, `internal/runtime2/binary_header.go`, and `internal/runtime2/shared_snapshot_header.go`. +- Added direct `BenchmarkHandleHostRegionSnapshotFingerprint` no-change/changed coverage in `internal/runtime2/perf_hotspot_bench_test.go` to track adapter-level fingerprint fast-path behavior separately from dispatch-level benchmarks. +- Optimized runtime2 patch identity hashing in `BuildPatchStreamIdentity(...)` by streaming canonical JSON directly into the FNV hasher (`buildJSONHashDigest(...)`) instead of allocating a full marshaled payload buffer. +- Added `BenchmarkBuildPatchStreamIdentityCurrentVsLegacy` in `internal/runtime2/perf_identity_compare_bench_test.go` so patch identity hashing can be measured against the legacy marshal-based implementation in one benchmark run. +- Runtime2 patch-identity benchmark deltas from `go test ./internal/runtime2 -run ^$ -bench BenchmarkBuildPatchStreamIdentity -benchmem`: + - `BenchmarkBuildPatchStreamIdentity/small`: median `1566 ns/op -> 1060 ns/op` and `521 B/op -> 160 B/op`. + - `BenchmarkBuildPatchStreamIdentity/large-keyed-rotate`: median `28533 ns/op -> 21252 ns/op` and `8365 B/op -> 160 B/op`. +- Reduced runtime2 patch-identity overhead again by pooling FNV hashers in `BuildPatchStreamIdentity(...)` via `sync.Pool` (`internal/runtime2/patch_stream.go`), removing one hot-path allocation per identity computation. +- Runtime2 patch-identity follow-up benchmark deltas from `go test ./internal/runtime2 -run ^$ -bench "BenchmarkBuildPatchStreamIdentity/(small|large-keyed-rotate)$" -benchmem -benchtime=700ms -count=5`: + - `BenchmarkBuildPatchStreamIdentity/small`: median `1300 ns/op -> 1273 ns/op`, `160 B/op -> 152 B/op`, `4 -> 3 allocs/op`. + - `BenchmarkBuildPatchStreamIdentity/large-keyed-rotate`: median `23618 ns/op -> 20409 ns/op`, `160 B/op -> 152 B/op`, `4 -> 3 allocs/op`. +- Optimized runtime2 host snapshot fingerprinting in `internal/runtime2/snapshot.go` and `internal/runtime2/host_region_adapter.go` by routing hot internal paths through the no-validation hash helper while preserving the existing marshal-based digest output contract, with compatibility coverage in `internal/runtime2/snapshot_hash_compare_test.go`. +- Added focused snapshot-hash compare benchmark coverage in `internal/runtime2/perf_snapshot_hash_compare_bench_test.go` (current path vs legacy marshal path) to keep this hot path measurable as runtime2 evolves. +- Runtime2 host-dispatch allocation deltas from `benchstat` (`pre-opt-pass2` vs `post-opt-pass2-final`): + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `22 -> 5 allocs/op` (`-77.27%`). + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: `29 -> 11 allocs/op` (`-62.07%`). + - `BenchmarkHandleHostRegionSnapshotFingerprint/no-change`: `22 -> 5 allocs/op` (`-77.27%`). + - `BenchmarkHandleHostRegionSnapshotFingerprint/changed`: `30 -> 12 allocs/op` (`-60.00%`). + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: `1055 -> 287 allocs/op` (`-72.80%`) and `12.00 KiB/op -> 11.63 KiB/op` (`-3.00%`). +- Saved this pass's reproducible benchmark artifacts under `bin/test-results/runtime2-bench/` (`pre-opt-pass2*.txt`, `post-opt-pass2*.txt`, and host/snapshot focused compare runs). +- Added canonical decode quick paths in `internal/runtime2/render_ir.go` and `internal/runtime2/render_node_table.go`: flat child-ID pooling, precomputed parent/child spans, direct raw-prop map decode (skip sort/copy path), and keyed-sibling early exits when duplicate checks are unnecessary. +- Runtime2 hot-path microbench deltas (`go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkBuildCanonicalPatchStream|BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction|BenchmarkParseCanonicalRenderTree|BenchmarkBuildPatchStreamIdentity|BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred)$" -benchmem -count 5`): + - Geomean: `-29.81% sec/op`, `-48.91% B/op`, `-27.75% allocs/op`. + - `BenchmarkParseCanonicalRenderTree`: `38.70us -> 21.69us`, `60.92KiB -> 59.10KiB`, `92 -> 19 allocs/op`. + - `BenchmarkCommitRegionPatchTransaction`: `5.799us -> 4.185us`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `1.449us -> 1.050us`, `11 -> 7 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: `2.315us -> 1.387us`, `23 -> 13 allocs/op`. + +- Added another runtime2 perf pass with conservative hot-path optimizations in `spec.go`, `snapshot.go`, `host_region_adapter.go`, and `render_node_table.go`: + - Added `isSerializableAnyFast(...)` to short-circuit common `map[string]any` / `[]any` payload validation before reflective traversal. + - Added `buildSnapshotEnvelopeFromNormalizedSourceIDsWithoutValidation(...)` and used it on already-normalized host update paths to avoid duplicate envelope validation work. + - Added sequential-node-ID and small-keyed-sibling duplicate-check fast paths in `ParseRenderNodeTable(...)` to cut map allocation pressure in canonical decode. +- Runtime2 full-bench deltas from this pass (`go test ./internal/runtime2 -run ^$ -bench . -benchmem -benchtime=200ms`): + - `BenchmarkParseCanonicalRenderTree`: `28178 ns/op, 65424 B/op, 22 allocs/op -> 23939 ns/op, 55616 B/op, 16 allocs/op`. + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: `67132 ns/op, 14969 B/op, 476 allocs/op -> 55362 ns/op, 11894 B/op, 285 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change`: `1077 ns/op, 320 B/op, 9 allocs/op -> 913.9 ns/op, 256 B/op, 5 allocs/op`. + - `BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed`: `1608 ns/op, 904 B/op, 19 allocs/op -> 1249 ns/op, 776 B/op, 10 allocs/op`. + - `BenchmarkHandleHostRegionSnapshotFingerprint/no-change`: `795.2 ns/op, 288 B/op, 7 allocs/op -> 653.1 ns/op, 256 B/op, 5 allocs/op`. + - `BenchmarkHandleHostRegionSnapshotFingerprint/changed`: `1218 ns/op, 872 B/op, 16 allocs/op -> 1120 ns/op, 808 B/op, 12 allocs/op`. + - `BenchmarkHandleHostRegionUpdateSnapshot`: `1408 ns/op, 1616 B/op, 16 allocs/op -> 1267 ns/op, 1552 B/op, 12 allocs/op`. +- Removed duplicated sibling-scan work in canonical patch planning by caching per-parent canonical sibling indexes and switching canonical move simulation to in-place slice updates, so hot-path anchor lookup and move planning avoid repeated linear rescans. +- Focused runtime2 microbench deltas for this pass (`go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkBuildCanonicalPatchStream|BenchmarkCommitRegionPatchTransaction|BenchmarkParsePatchStreamTransaction)$" -benchmem -count 5`): + - Geomean sec/op: about `-1.59%`; allocations unchanged across the measured benches. + - `BenchmarkBuildCanonicalPatchStream`: `5.069 us -> 4.979 us`. + - `BenchmarkCommitRegionPatchTransaction`: `3.636 us -> 3.604 us`. + - `BenchmarkParsePatchStreamTransaction`: `522.0 ns -> 511.0 ns`. +- Removed duplicated patch-transaction parse work in `ParsePatchStreamTransaction(...)` by dropping the redundant pre-pass patch-order walk and by lazily cloning sibling/known-node/removal tracking maps only for op kinds that mutate or require those structures. +- Runtime2 microbench deltas for this parse-lazy-allocation pass (`go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction|BenchmarkBuildCanonicalPatchStream)$" -benchmem -count 8`): + - `BenchmarkParsePatchStreamTransaction`: `768.6 ns -> 530.1 ns`, `1040 B/op -> 976 B/op`, `6 -> 5 allocs/op`. + - `BenchmarkCommitRegionPatchTransaction`: `5.549 us -> 4.458 us`, `6864 B/op -> 6800 B/op`, `53 -> 52 allocs/op`. + - `BenchmarkBuildCanonicalPatchStream` was also sampled in the same run; this pass did not directly modify canonical diff generation. +- Removed unneeded sibling-bound lookup work on host patch commit paths that do not include keyed-move ops by reusing `BuildKnownNodeIDsForRegionDOMIndex(...)` and only building sibling counts when `parseHasPatchKeyedMoveOp(...)` is true. +- Runtime2 keyed-move-guard microbench deltas (`go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers|BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction)$" -benchmem -count 5`): + - `BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers`: `56.97 us -> 50.72 us` (`-10.97% sec/op`). + - `BenchmarkParsePatchStreamTransaction` and `BenchmarkCommitRegionPatchTransaction`: no statistically significant regression in this sample set. +- Removed duplicated/unneeded keyed-move prep work in runtime2 patch paths by deferring keyed-move-op scans until sibling bounds are actually needed in `ParsePatchStreamTransaction(...)`, and by only storing sibling-count entries for parent nodes that currently have at least one child in `BuildRegionDOMPatchLookupMaps(...)` and `BuildSiblingCountByParentForRegionDOMIndex(...)`. +- Runtime2 sibling-count map guard microbench deltas (`go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction)$" -benchmem -count 8`): + - `BenchmarkParsePatchStreamTransaction`: `566.1 ns -> 442.4 ns` (`-21.84% sec/op`). + - `BenchmarkCommitRegionPatchTransaction`: `3.881 us -> 3.613 us` (directional improvement, not statistically significant in this sample set). +- Removed unneeded reverse string-ref map allocations on runtime2 patch-parse paths by making `ParseRenderStringTable(...)` validate + copy entries without building `storeRenderStringRefByString`, and by adding a fallback linear lookup in `GetRenderStringRef(...)` only for parsed-table call sites that actually require reverse lookup. +- Runtime2 parsed-string-table guard microbench deltas (`go test ./internal/runtime2 -run ^$ -bench "^(BenchmarkParsePatchStreamTransaction|BenchmarkCommitRegionPatchTransaction|BenchmarkBuildCanonicalPatchStream)$" -benchmem -count 8`): + - Geomean: `-23.63% sec/op`, `-10.86% B/op`, `-16.73% allocs/op`. + - `BenchmarkParsePatchStreamTransaction`: `490.1 ns -> 301.6 ns`, `976 B/op -> 720 B/op`, `5 -> 3 allocs/op`. + - `BenchmarkCommitRegionPatchTransaction`: `4.572 us -> 4.047 us`, `6400 B/op -> 6144 B/op`, `53 -> 51 allocs/op`. + - `BenchmarkBuildCanonicalPatchStream` was sampled in the same run with no code-path changes in canonical diff generation from this pass. + +### Example 201 browser benchmark harness + +- Added `examples/testing/render-benchmark`, including runtime1, runtime2 (single-worker), runtime2 (4-worker), and React 18 subjects with shared scenario contracts and local vendored browser assets. +- Added Playwright-Go benchmark automation (`TestExample201BrowserBenchmarkReport`) that builds wasm artifacts, executes seeded browser scenarios, and emits structured JSON + Markdown reports under `bin/test-results/example-201-browser-benchmark/`. +- Added a `content-card refresh` scenario so the browser suite now measures refresh-only behavior for both core-list and content-card views. +- Revised the browser harness to wait for DOM-settle frames after scenario preparation, reducing prepare-phase mutation spillover into the measured RT2 window and making mutation counts and timing comparisons fairer. +- Removed RT2-only benchmark DOM metadata from the rendered core/content shells so the benchmark no longer charges runtime2 for debug-only attribute churn that React and runtime1 were not paying. +- Extended the browser report schema and rendered tables with worker-preparation diagnostics for the runtime2 subjects, including batch-count deltas, last-batch duration, and prepared-item counts for the measured run window. +- Optimized the single-worker runtime2 benchmark path by matching chunk fan-out to the configured worker count, so the one-worker mode no longer pays four-request and four-region overhead for one-worker preparation batches. +- Added configurable `Runtime 2 (N Workers)` benchmark support through the Example 201 runner, subject route, and worker-count query parsing, with focused Playwright coverage for custom worker counts. +- Documented the Example 201 benchmark workflow in `examples/README.md` and `docs/PERFORMANCE.md`. +- Replaced runtime2 worker-preparation dispatch in `examples/testing/render-benchmark/workers.go` from `interop.WorkerPool` arbitration to a dedicated worker-fleet lane model (`[]interop.Worker`) with direct chunk-to-worker requests, removing queue/admission overhead on each prep batch. +- Optimized worker batch fanout by reusing one resolved `runtime2WorkScale` value per batch and passing chunk sub-slices directly (instead of per-chunk copy allocations) for core/content worker requests. +- Kept worker-mode behavior and metrics contracts stable (`metric-worker-count`, `metric-worker-batch-count`, `metric-worker-items`, `metric-worker-batch-ms`) while adding empty-fleet guard errors for clearer failure diagnostics. +- Added `docs/WORKER_POOLS_VS_LANES.md` and linked it from docs indexes so worker-heavy features have one explicit decision guide for `interop.OpenWorkerPool(...)` versus direct worker-lane fanout. +- Focused dispatch microbench sample (`go test ./interop -run ^$ -bench BenchmarkRequestWorkerDecodedFanoutDispatch -benchmem -count=3`, Windows/amd64, i7-12700) still shows direct-lane fanout faster than pooled dispatch: + - `direct-lanes`: about `18.4-21.5 us/op`, `~3380 B/op`, `83 allocs/op`. + - `worker-pool`: about `28.6-30.1 us/op`, `~3395 B/op`, `83 allocs/op`. +- Revalidated Example 201 integration after this dispatch change: + - `go test ./test/playwrightgo/examples -tags playwrightgo -run TestExample201BrowserBenchmarkHonorsConfiguredWorkerCounts -count=1` + - `go test ./test/playwrightgo/examples -tags playwrightgo -run TestExample201BrowserBenchmarkReport -count=1` +- Added explicit worker-dispatch strategy support for Example 201 runtime2 subjects via `runtime2Dispatch`: + - `runtime2Dispatch=batch` (default): one multi-chunk request per worker lane. + - `runtime2Dispatch=chunk`: legacy one-request-per-chunk dispatch. +- Updated `examples/testing/render-benchmark/benchmark-runner.js` to forward `runtime2WorkScale` and `runtime2Dispatch` query params into each subject iframe route, so stress and dispatch A/B routes now propagate as documented. +- Hardened Example 201 worker-prepare effect dependency tracking in `examples/testing/render-benchmark/workers.go` with comparable content-hash dependency tokens for core/content payloads; this removed stale-payload scheduling races seen during structural-churn scenarios (`core-reverse` under multi-worker runs). +- Added richer benchmark timeout diagnostics in `examples/testing/render-benchmark/benchmark-subject.js` (framework, worker status, last action, and row-order break window) so flaky scenario failures surface actionable context in CI logs. +- Added focused dispatch A/B benchmark automation in `TestExample201BrowserBenchmarkDispatchCompare` and report outputs: + - `bin/test-results/example-201-browser-benchmark/browser-benchmark-report-rt2-dispatch-chunk.{json,md}` + - `bin/test-results/example-201-browser-benchmark/browser-benchmark-report-rt2-dispatch-batch.{json,md}` +- Dispatch compare sample (`go test ./test/playwrightgo/examples -tags playwrightgo -run TestExample201BrowserBenchmarkDispatchCompare -count=1 -v`, Windows/amd64, i7-12700): + - Worker-batch mean across worker-metric scenarios: `12.973 ms -> 10.277 ms` (`+20.78%` faster in `batch` mode). + - DOM-ready mean across worker-metric scenarios: `27.828 ms -> 25.101 ms` (`+9.80%` faster in this sample). +- Added a runtime2 local core fast path in `examples/testing/render-benchmark/workers.go` for small core batches (`<= 64` items): when enabled, this path bypasses worker RPC and uses one local cache-backed prepared-item map to reduce request/listener/structured-clone overhead on update-heavy small-list scenarios. +- Added a public query toggle `runtime2CoreFastPath` (`on` by default, `off` to force worker RPC) and forwarded it through `examples/testing/render-benchmark/benchmark-runner.js` so route-level A/B checks stay reproducible. +- Added an inline runtime2 core-update fast path in `examples/testing/render-benchmark/main.go` so small core updates that qualify for `runtime2CoreFastPath` prepare and store core chunks in the click-event path (with cache + generation updates) before the effect fallback runs; this removes extra effect-cycle latency on `Core Update`. +- Hardened `examples/testing/render-benchmark/benchmark-runner.js` iframe subject loading/inspection paths with `SecurityError` guards around cross-window property reads, preventing benchmark aborts on transient cross-origin window access during Playwright runs. +- Focused Core Update sample on the mixed-framework report route (`go test ./test/playwrightgo/examples -tags playwrightgo -run TestExample201BrowserBenchmarkReport -count=1`): + - `RT2x1`: `8.500 ms -> 4.271 ms` (`-49.75%` DOM-ready). + - `RT2x2`: `9.143 ms -> 3.714 ms` (`-59.38%` DOM-ready). + - `RT2x4`: `10.429 ms -> 3.714 ms` (`-64.39%` DOM-ready). + - `RT2x8`: `10.500 ms -> 3.500 ms` (`-66.67%` DOM-ready). +- Repeated direct runner A/B sample (`/examples/testing/render-benchmark/?iterations=11&warmups=2&seed=20101&runtime2WorkerCounts=1,2,4,8`, `runtime2CoreFastPath=on` vs `off`) confirms additional `Core Update` wins with the inline path: + - `RT2x1`: `5.764 ms -> 4.173 ms` (`-27.60%` vs fast-path off). + - `RT2x2`: `4.873 ms -> 3.945 ms` (`-19.04%` vs fast-path off). + - `RT2x4`: `4.182 ms -> 2.809 ms` (`-32.83%` vs fast-path off). + - `RT2x8`: `5.127 ms -> 3.936 ms` (`-23.23%` vs fast-path off). + +### Parallel-region runtime status surface and diagnostics docs + +- Added a public read-only `ui.GetParallelRegionRuntimeStatus(...)` helper and `ui.ParallelRegionStatus` shape so apps and tooling can inspect one tracked region's ownership mode, shard assignment, epoch, hydration flags, snapshot and dispatch and commit versions, transport tier, stale counters, and fallback reason without touching mutable runtime2 internals. +- Added focused regression coverage in `ui/parallel_region_test.go` and `ui/ui_wasm_test.go` for public status validation, missing-region behavior, dispatch-version reporting, and hydrated attach-state reporting. +- Added `examples/200-runtime2-status` plus `examples/README.md` indexing so adopters can inspect the public runtime-status contract in a dedicated tooling-style panel. +- Updated `examples/testing/parallel-region-basic`, `examples/109-parallel-region-grid`, and `examples/110-parallel-region-diagnostics` copy and diagnostics surfacing to reflect current local-first shell ownership with active runtime2 dispatch and operator metrics. +- Updated parallel-region docs in `docs/PARALLEL_REGION_AUTHORING.md`, `docs/PARALLEL_REGION_TROUBLESHOOTING.md`, and `docs/REFERENCE_MAP.md` with transition semantics and operator-facing runtime-status field guidance, and marked completed multithreaded-runtime follow-ups in `docs/MULTITHREADED_RUNTIME_TODO.md`. + +### GoGRPCBridge submodule hardening and release alignment + +- Advanced `third_party/GoGRPCBridge` to `1b39bbc` with grouped security hardening, abuse controls, observability hooks, release workflow guardrails, generated docs-page sync, and a checked-in docs catalog manifest. +- Updated repo-level GoGRPCBridge governance and rollout docs (`docs/GOGRPCBRIDGE_DEV_TO_PROD_ROADMAP.md`, `docs/GOGRPCBRIDGE_REQUIRED_CHECKS.md`, `docs/GOGRPCBRIDGE_SUBMODULE_LIFECYCLE.md`, `docs/GOGRPCBRIDGE_INTEGRATION_MATRIX.md`, `docs/REFERENCE_MAP.md`, `docs/README.md`, and `docs/TODO.md`) to reflect current required checks and lifecycle expectations. +- Hardened CI and release workflow wiring for the GoGRPCBridge integration path in `.github/workflows/gogrpcbridge-ci.yml` and `.github/workflows/release.yml`. + +### Example 100 and coverage expansion + +- Expanded `examples/server/ai-chat-wizard` build, seed, server, and tunnel surfaces with follow-up fixes and targeted regression coverage. +- Added focused additional coverage suites across examples, runtime, UI, browser/render helpers, and `tools/gwc` command paths to close branch and helper gaps. +- Added `.github/CODEOWNERS` plus shared bootstrap/test artifacts in `scripts/bootstrap-gogrpcbridge.ps1` and `third_party/_shared/data/todos.json`. + +### Runtime helper consistency updates + +- Added multithreaded runtime follow-up documentation in `docs/MULTITHREADED_RUNTIME.md` and `docs/MULTITHREADED_RUNTIME_TODO.md`. +- Applied helper-path consistency updates in `interop`, `i18n`, and UI form native/non-native paths, with corresponding module dependency updates in `go.mod` and `go.sum`. + +## 2026-03-26 + +### Worker multithreading primitives and lifecycle hardening + +- Added first-class worker coordination primitives in `interop`, including `MessageChannel`/`MessagePort` support, transferred-port posting helpers, `SharedBuffer` shared-memory APIs, `Atomics` wait/notify wrappers, and nested structured transport for shared buffers and binary payloads. +- Added `OpenWorkerPool(...)` with bounded queueing, graceful drain/close behavior, typed request routing through the existing decoded helpers, and worker replacement or fail-fast shutdown when pooled workers are unexpectedly disposed. +- Hardened worker lifecycle handling across `interop` and `ui`, including bad-message failure paths, duplicate worker-start protection, stale cancel cleanup, and explicit worker subscription teardown in the Example 100 chat runtime. +- Expanded native and js/wasm worker coverage with focused regression tests for worker-to-worker port communication, shared-memory coordination, pool scheduling and repair, nested payload transport, and `UseWorkerTask(...)` terminal-state handling. + +### Launcher lint workflow documentation + +- Documented the repo-local `gwc lint` / `gwc review` workflow in `docs/TESTING.md`, including saved-report commands, auto-install behavior for the default `golangci-lint` binary, and the non-zero exit contract when findings are present. + +### Lint cleanup and runtime pool guardrails + +- Cleared outstanding lint findings across runtime, interop, launcher, i18n, and UI test surfaces, including staticcheck, gosimple, govet, ineffassign, and unused diagnostics reported through `gwc lint`. +- Fixed runtime scratch-slice pool usage patterns that triggered `SA6002` by switching reconciler scratch pools to pointer-backed typed wrappers with dedicated `get`/`clear` helpers. +- Updated focused runtime lint coverage paths so reconciler branch tests and scratch-pool call sites now use the guarded helper APIs instead of raw `sync.Pool.Put` with slice values. + +### Example 100 API migration and lint recovery + +- Migrated `examples/server/ai-chat-wizard` to the current launcher/runtime APIs, including updated client state and helper field names, background worker interop calls, gRPC client/test method names, and markdown/sql helper callsites. +- Restored Example 100 build and verification flow so both client wasm and server packages compile and `gwc verify` passes for the example root. +- Cleared launcher lint findings for Example 100 by fixing unused-path drift, staticcheck callback assertions, errcheck cleanup in store/test helpers, and removing dead legacy helpers. + +## 2026-03-25 + +### Launcher lint runbook and Playwright deprecation follow-up + +- Documented the launcher-owned `gwc lint` / `gwc review` workflow in `docs/TESTING.md`, including saved-report examples, auto-install behavior for the default `golangci-lint` binary, and the expected non-zero exit contract when findings are present. +- Updated the release startup Playwright probe in `tools/gwc/main.go` to use locator-based click interaction instead of the deprecated page-level `Click(...)` API. + +### Starter scaffold output refresh + +- Refreshed `gwc start` scaffold generation and the checked-in starter goldens, including updated generated `main.go` and starter test fixtures for standalone, contributor-linked, SSR, and browser-test starter variants. + +### Naming-sweep compile and launcher follow-up + +- Restored missed helper and field references across `router`, `tools/gwc`, and selected runtime tests after the naming and GoDoc sweep so the router, UI, and launcher packages compile again under the repo-local test cache. +- Fixed managed example-server runtime state and log artifacts to honor `gwc-runner.json` `paths.artifactRoot` directly instead of inserting the workspace artifact namespace. + +### Adoption maturity, shell-routing, and enterprise guidance + +- Added `docs/ADOPTION_MATURITY.md` to define feature-area readiness tiers, starter support tiers and cadence, ecosystem maintenance signals, enterprise evaluation packet expectations, and guided learning/community-growth lanes. +- Added `docs/CLIENT_SHELL_ROUTING.md` to document the recommended single-runtime route-tree pattern for mixed marketing, auth, workspace, and canvas flows inside one GoWebComponents client shell. +- Added `docs/TEAM_CONVENTIONS.md` and `docs/ENTERPRISE_PILOT.md` to capture team-scale architecture conventions, review and migration checklists, component-library workflow guidance, enterprise pilot gates, incident runbook expectations, and deployment validation checklists. +- Updated `docs/README.md` and `docs/TODO.md` to index the new guidance and mark the related adoption, shell-routing, team-conventions, and enterprise-pilot roadmap items complete. + +### Example 100 marketing heading consolidation + +- Shared the Example 100 landing and pricing top-bar shell, brand block, and CTA actions through common marketing-page helpers so those page headers no longer drift visually. +- Shared the Example 100 landing and pricing hero heading treatment so the eyebrow, headline, body copy, and CTA row stay aligned across both pages. + +### Launcher lifecycle, profiling, and testkit expansion follow-up + +- Added first-class launcher lifecycle and delivery commands: `gwc init`, `gwc inspect`, `gwc upgrade`, `gwc migrate`, `gwc prerender`/`gwc export`, and `gwc deploy`, with associated tests and runner-config/dev-runtime integration updates. +- Aligned generated/imported wasm output paths to `bin/main.wasm` across scaffold templates, CI golden fixtures, and import-generated HTML startup scripts. +- Expanded public test surfaces with richer `testkit/render`, `testkit/router`, and `testkit/ssr` helpers plus a new `test/browser` coordination harness, including render-count and warning assertion utilities for wasm fixtures. +- Added runtime startup-cost attribution and route startup budget reporting (runtime + devtools), with new regression fixtures for small, routed mid-sized, and production-shaped profiling budgets. +- Added `examples/107-server-interactive-poc`, refined `examples/server/ai-chat-wizard` shell and bootloader phase handling, and updated related regression tests. +- Extended GoDoc/API-audit coverage across diagnostics, html/i18n/interop/pwa/state/ui helper surfaces, and checked in function inventory/audit reports used by the naming review workflow. + +### Grouped cleanup of legacy scripts and fixtures + +- Removed deprecated example shell and PowerShell helper scripts from `examples/` and Atlas docs script scaffolding paths. +- Removed legacy Node and JSX helper artifacts, including runner path scripts, dev-server Node entrypoints, test-build script wrappers, import fixtures, and stale docs/example placeholders. + +### Agent guidance refresh for gwc usage + +- Simplified `AGENTS.md` into a terse operator format and added a compact `gwc` command map with effective feature coverage, key flags, primary docs links, and practical command examples. + +### GWC launcher expansion, browser-suite migration, and Example 100 UI refresh + +- Added launcher-owned wasm experiment helpers under `gwc wasm` (`measure`, `compare`, `compare-compression`, `compare-cache`, `compare-toolchain`) plus `gwc bench` compare/capture follow-ups and updated launcher docs around the expanded benchmark and wasm workflow. +- Added `gwc env` so operator-facing environment variables can be inspected in text or JSON output with secret-shaped values redacted by default. +- Documented `gwc env` in both `docs/GWC.md` and `tools/README.md`, including JSON output and redaction behavior guidance. +- Migrated remaining browser-suite and workspace wiring from npm/TypeScript Playwright configs to launcher-owned Playwright-Go flows, removed deprecated npm test workspaces and legacy spec/config files, and updated docs/workflow references to match. +- Refreshed `examples/server/ai-chat-wizard` landing/auth/pricing surfaces, updated chat-shell bootstrap copy and related server tests, and rebuilt shared Tailwind output through the launcher-owned CSS pipeline. +- Fixed Example 100 landing-header navigation actions to use app-route-aware links for home/pricing/login/chat entry behavior. +- Removed deprecated `tools/*.ps1` and `tools/*.sh` wrapper scripts now superseded by the launcher-owned `gwc` command surface. +- Removed legacy `test/browser/index.ts` and `test/browser/index.test.ts` bridge files that were tied to the older browser-harness path. +- Removed checked-in generated browser helper/service-worker/static-script artifacts from examples static/script paths that are now treated as generated runtime assets. + +### Tailwind CLI first-class launcher workflow + +- Added a first-class `gwc tailwind` command in `tools/gwc` that regenerates the shared Tailwind manifest and stylesheet without npm, with machine-readable `-json` output support. +- Added standalone Tailwind CLI download and cache management under `third_party/tailwindcss/bin//`, including checksum verification against the upstream `sha256sums.txt` release artifact when available. +- Updated `examples/server/ai-chat-wizard/cmd/build-client` to run `go run ./tools/gwc tailwind` before wasm compilation so Example 100 no longer depends on npm for CSS rebuilds. + +### GWC benchmark scoring and launcher decomposition follow-up + +- Extended `gwc bench` with package-level parallelism, checked-in `docs/benchmarks/reference.json` baselines, and reference-normalized geometric bucket scores so benchmark runs keep their raw `ns/op`, `B/op`, and `allocs/op` data while also emitting a stable summary score for regression tracking. +- Split the oversized `tools/gwc/main.go` launcher file into command-specific modules such as `dev.go`, `doctor.go`, `examples.go`, and `start.go`, and added `tools/gwc/docs/README.md` so future launcher work has a clearer ownership map. +- Aligned the launcher browser lane with the checked-in Playwright-Go package layout so browser test workspace discovery and the focused `tools/gwc` tests continue to match the repo-owned runner contract. + +### Model picker persistence hardening in Example 100 + +- Fixed `examples/server/ai-chat-wizard` model selection persistence so new chats no longer land in a blank provider/model state after reconnects or stale cached preferences. +- Added client-side recovery for invalid or blank persisted model selections, with deterministic fallback to the first available catalog model and persisted repair back to the server. +- Added server-side `GetSelectedModel` fallback repair and persistence so normalized model preferences stay stable across sessions. +- Added focused regression coverage for selection-repair behavior in both client wasm tests and server RPC tests. + +### Example 100 speech synthesis fallback and opt-in flow + +- Added an OpenAI TTS-only fallback path in `examples/server/ai-chat-wizard` so speech playback can be enabled without switching the active chat provider or selected model for normal text generation. +- Added client-side helper coverage for selecting a speech-capable OpenAI synthesis model, plus UI copy and modal-flow updates that describe the new opt-in behavior explicitly. +- Removed the older model-preferences speech-provider switch path and centralized speech-model resolution inside the TTS controller instead of mutating the user's saved chat provider preference. + +### Playwright-Go rollout and Example 100 runtime hardening + +- Replaced the repo and examples browser npm entrypoints, release smoke steps, and compatibility workflow with Go-based `playwrightgo` suites, and updated the browser-support and runner-config docs to match the new browser-workspace contract. +- Hardened `examples/server/ai-chat-wizard` memory extraction by sending a strict OpenAI JSON-schema response request, adding lifecycle and save-failure logging around extraction, and tightening provider HTTP coverage for the structured payload. +- Exposed a configurable usage-premium percentage in the Example 100 chat bootstrap script so client-side surfaces can read the server-defined premium multiplier during startup. +- Added account-level cost aggregation in the Example 100 client so the composer can show premium-adjusted account totals with coverage-gap handling on top of the existing per-thread cost summary. + +### Tooling, devtools, and testing expansion wave + +- Expanded the `gwc` launcher with dashboard/start TUI work, broader release/build/import/start/verify coverage, extracted `tools/runnerconfig` docs and tests, and new starter golden fixtures for standalone, contributor-linked, browser-test, and SSR app templates. +- Expanded `devtools` with bug-capture, support-bundle, trace-capture, serialization-boundary, extension-section, and richer runtime snapshot plumbing, backed by substantial wasm/native test coverage. +- Broadened Example 100, Atlas Commerce OS, SSR, interop, plugin, PWA, router, UI, and runtime coverage with a large set of focused regression tests, plus new public `test/browser` helpers and additional `testkit` consumer fixtures. +- Added and documented new example coverage for static islands, staged rollout config, SSR route helpers, virtualization, and the repo examples site while refreshing ecosystem, IDE, testing, and runner-config docs. +- Removed checked-in generated coverage/build artifacts from the tree and tightened ignore rules so local coverage output no longer pollutes status or release-oriented workflows. + +### API naming and launcher workflow consolidation + +- Aligned public API naming across `ui`, `utils`, `fetch`, `hotreload`, `logging`, and `devtools`, including test and example call-site updates and refreshed `docs/PUBLIC_API_CONVENTIONS.md` guidance. +- Extended launcher-owned tooling with stronger `runnerconfig` coverage and a new `gwc files` surface for filtered project file inventory output with repeatable extension and directory filters. + +### Bench coverage and benchmark reporting + +- Added micro-benchmark coverage across core and companion packages (including `devtools`, `diagnostics`, `fetch`, `head`, `hotreload`, `html`, `i18n`, `interop`, `logging`, `plugin`, `prerender`, `pwa`, `router`, `state`, `ui`, `utils`, `virtualization`, `testkit`, and `tools/runnerconfig`) to keep benchmark regressions visible in routine development. +- Added `gwc bench` to discover benchmark-bearing packages, run both native and `js/wasm` lanes, and write machine-readable benchmark snapshots to `docs/benchmarks/latest.json` with baseline-to-current delta comparison support. +- Documented the launcher benchmark workflow in `docs/PERFORMANCE.md` and `tools/README.md`, including lane selection and JSON output behavior for automation and CI. + +### Example Playwright and chat-wizard follow-ups + +- Relocated example-specific Playwright configs under `test/playwright/examples`, updated `examples/package.json` scripts, and refreshed docs/manual-smoke references so example test entrypoints resolve from one centralized config location. +- Refined Example 100 chat-wizard desktop UI spacing and control styling (composer controls, panel density, sidebar row emphasis, and message-meta contrast) for cleaner day-to-day operator ergonomics. + +### Optional Playwright-Go smoke lane + +- Added a build-tagged `test/playwrightgo` Chromium smoke test that validates the `playwright-go` driver/browser lifecycle and a minimal page interaction path. +- Added the required Playwright-Go module dependencies so the smoke lane can be enabled explicitly without changing default repo test behavior. + +## 2026-03-24 + +### Example 100 AI chat wizard and supporting tooling + +- Added a new `examples/server/ai-chat-wizard` full-stack showcase with a Go `js/wasm` client, Go server, gRPC-over-WebSocket bridge, SQLite-backed auth and conversation persistence, per-user settings and memories, streamed assistant replies, worker-backed markdown rendering, and focused Playwright/manual test support. +- Added richer chat-product behavior across the example, including reconnect and idle-resume handling for the gRPC bridge, collapsible assistant thinking sections, per-message and per-thread token-cost display, Mermaid and KaTeX rendering in message bubbles, TTS playback wiring, smoother streaming scroll behavior, and a stronger wasm/bootstrap loading shell. +- Added a canvas-style code workspace path for previewable assistant artifacts with split chat/canvas layout, canvas session state, focus-region editing, patch history, console capture, overlay mode, and a dedicated canvas-only route. +- Moved the example build output and runtime data into `examples/server/ai-chat-wizard/bin/`, added dedicated build/run scripts, runtime SQL-file loading, local Tailwind build support for the example shell, and follow-up cleanup so legacy source-tree wasm outputs are removed instead of accumulating under `client/`. + +### Browser interop worker and scroll primitives + +- Expanded `interop` with safer JavaScript exception wrapping for `Value.Invoke(...)` and `Value.Call(...)`, preserving thrown browser errors as structured remote failures instead of surfacing vague panics or illegal-invocation behavior. +- Added explicit element scroll helpers through `Element.SetScrollTop(...)` and `Element.ScrollMetrics(...)` so apps can drive scroll containers directly without ad hoc `syscall/js` reads and writes. +- Added `NewGoWASMWorker(...)`, `CurrentWorkerScope()`, and `WorkerScope` helpers so Go-authored wasm workers can be bootstrapped from `wasm_exec.js` plus a wasm module URL while still using the existing worker message envelope and request/progress/result pattern. +- Added native/wasm coverage around worker bootstrapping, JS exception wrapping, receiver-bound method calls, and browser storage method invocation so the new interop helpers stay consistent across runtime and tests. + +### Smaller framework and docs follow-ups + +- Added `OnMouseUp(...)` support to the public `html` props surface and the shorthand/sugar helpers, with tests proving the prop is emitted and wrapped consistently with the other event helpers. +- Fixed wrapped panic unwrapping for uncomparable payloads so reported panic wrappers preserve original map-like payloads instead of losing the underlying deferred/runtime failure context during repeated wrapping. +- Added the `28-scaling-local-state-with-use-reducer` example and supporting docs so reducer-based local-state composition has a smaller focused teaching surface alongside the larger examples and workflow docs. + +## 2026-03-22 + +### HTML authoring sugar, shorthand ergonomics, and browser validation + +- Added the first additive `html` authoring sugar layer, including `Children(...)`, `Textf(...)`, `TextIf(...)`, `When(...)`, `ClassNames(...)`, `If(...)`, `IfElse(...)`, `Unless(...)`, `Map(...)`, `MapKeyed(...)`, `FlatMap(...)`, `FilterMap(...)`, `Join(...)`, `Maybe(...)`, `OrElse(...)`, `Coalesce(...)`, `Switch(...)`, `Case(...)`, `Default(...)`, `PropsOf(...)`, `WithProps(...)`, first-pass prop helpers, explicit event-wrapper helpers, and closure-scoped `Debounce(...)` and `Throttle(...)` helpers so primitive DOM composition can be lighter without replacing the stable typed builder surface. +- Added the companion `html/shorthand` package with mixed-argument host-tag wrappers such as `Div(...)`, `Button(...)`, and `Input(...)`, plus `FromProps(...)`, while keeping the existing typed `html.Div(...)` builder family compatibility-stable for existing `[]ui.Node` call sites. +- Extended SSR to render reactive text nodes correctly, broadened native, shorthand, and exact-markup test coverage for the html surface, and pushed html package coverage beyond the targeted threshold with parity checks against explicit builders. +- Updated package docs, API policy, roadmap tracking, and several examples to demonstrate both `PropsOf(...)`-style additive sugar and the companion shorthand path, including form-heavy, toggle, todo, and html-form example flows. +- Hardened the browser smoke-test harness by making the Playwright web-server port configurable, then validated the mounted html path with focused and broader Playwright suites plus a direct manual smoke pass covering input, form submit, effect mount or cleanup, todo creation, and fetch-driven rendering. + +### Static HTML and JSX converter workflow + +- Added a new `gwc import` launcher command that converts static `.html`, `.htm`, `.jsx`, and `.tsx` sources into a single inspectable `main.go` built from the public `html` builder API instead of generating an opaque scaffold or hidden transform output. +- Added focused parser and generation coverage in `tools/gwc/import_test.go`, together with persisted converter fixtures under `test/gwc-import-fixtures/` that exercise nested structures, custom tags, boolean and raw attributes, `data-*`, `aria-*`, style maps, and explicit rejection of dynamic JSX child expressions. +- Moved launcher-owned temporary output from the OS temp directory into `bin/tmp/` so release-test and converter-adjacent temporary artifacts stay rooted under the project tree. +- Added ignored repo-local converter preview outputs under `bin/converter/` and validated the catalog fixture visually by running both the original HTML and converted wasm app, capturing screenshots for each, and confirming the rendered output matched at the browser level. + +### GWC launcher coverage and examples runtime + +- Added broad launcher coverage for `tools/gwc`, including focused tests for `build`, `release`, `test`, `verify`, `examples`, project detection and config precedence, the `start` Bubble Tea scaffold flow, runner-config overrides, and launcher output helpers so the newer CLI surface is exercised as a maintained contract instead of only by ad hoc manual checks. +- Promoted the repo examples catalog toward a launcher-owned runtime by adding a dedicated `examples/gwc-examples-site` `js/wasm` application, generating `examples/static/catalog.json`, and replacing the older mostly static examples shell with a richer catalog experience that can load, filter, and persist catalog state from the served metadata. +- Updated the repo tooling docs to describe `gwc` as the canonical launcher for build, release, examples, dev, doctor, test, verify, and start workflows, including the current `gwc-runner.json` override points for enterprise-oriented path configuration. +- Hardened the browser-facing PWA and interop support layer with explicit wasm browser-global helpers plus expanded wasm and native coverage around persistence, installability, service-worker, and diagnostics paths so browser-only helpers behave consistently in test and runtime environments. + +## 2026-03-21 + +### PWA helpers and durable offline persistence + +- Added a new public `pwa` companion package with explicit web-app manifest helpers, installability observation, service-worker registration and update-lifecycle helpers, wasm-release-manifest-driven asset planning, Cache Storage coordination, and structured diagnostics so PWA behavior stays app-owned instead of hidden in the core rendering runtime. +- Added a first-class IndexedDB-first durable persistence seam through `interop.OpenPersistentStore(...)`, including typed JSON helpers, blocked-upgrade and quota-aware interop error codes, opt-in corruption recovery, and focused native and `js/wasm` coverage for IndexedDB and fallback-storage behavior. +- Extended `fetch` with opt-in durable shared-cache persistence through `CacheOptions.Persist` and `fetch.ConfigurePersistentCache(...)`, and moved the offline mutation queue onto the same IndexedDB-first persistence boundary while preserving explicit fallback storage control. +- Extended `state` with `SavePersistentSnapshot(...)`, `LoadPersistentSnapshot(...)`, and `RestorePersistentSnapshot(...)` so atom snapshots can survive reloads through the same durable browser-storage boundary used by cache and queue helpers. +- Added runnable PWA examples for installability and offline cache or replay behavior, plus focused Playwright coverage for installability state, service-worker update flow, offline shell warmup, stale cache cleanup, queued write replay, offline navigation fallback, and cross-tab coordination. +- Extended the offline PWA slice with app-owned Background Sync registration through `pwa.ServiceWorkerRegistration.RegisterSync(...)`, conflict-aware offline replay via `fetch.ReplayWithOptions(...)` plus `fetch.NewMutationConflict(...)`, and example coverage for graceful Background Sync fallback plus conflict requeue resolution. +- Expanded the platform docs around PWA scope, Cache Storage policy, offline mutation retention, cross-tab replay ownership, release-manifest reuse, security posture, manual testing, and backlog status so the new offline behavior is documented as an explicit public contract. + +### Unified test runner and harness stabilization + +- Added a canonical repo-root `npm test` entrypoint that runs the main native Go suite, the `js/wasm` Go lane, the nested `tools/livereload` Go tests, the primary Playwright workspace under `test/`, and the aggregated Playwright suites under `examples/` from one orchestrated runner. +- Added `scripts/run-main-tests.mjs` plus focused root scripts for each lane so contributors can run the full matrix or isolate one lane without manually hopping across workspaces. +- Hardened the Windows-oriented harness flow by scrubbing leaked `GOOS` and `GOARCH` values for native tools, invoking nested npm workflows through the active Node/npm runtime, and making Playwright worker counts configurable from the environment for stability. +- Folded more example coverage into the main path by aggregating dedicated example suites such as SSR server-routing, Atlas SSR, and startup experiments under the examples workspace `test:all` script. +- Stabilized the selective hot-reload Playwright coverage by using ephemeral ports, draining dev-server output, detecting early startup exits, clearing stale wasm artifacts before startup, and waiting for a single remounted changed subtree before asserting preservation behavior. +- Simplified one brittle browser stress assertion so the test continues to validate user-visible state correctness without depending on incidental render-count behavior. + +### Wrapped panic contract and actionable runtime diagnostics + +- Added a unified wrapped-panic reporting path across runtime render, event, effect, cleanup, loader, hydration, startup, deferred, and SSR failure phases, keeping the original panic payload while attaching stable framework codes, `where:` context, component or route `path:`, plain-language runtime consequences, remediation guidance, and grouped app/framework/platform stack sections. +- Added structured panic reporting hooks and browser-console emission support so wrapped fatal panics can be mirrored consistently into runtime diagnostics, buffered logs, devtools snapshots, and browser-observed Playwright assertions instead of appearing as raw low-context Go panic output. +- Expanded actionable framework misuse messages for hooks, atom access, `ui.CreateElement(...)`, server-only UI APIs, router registration, and nil-context misuse so invalid public API usage now follows the same stable diagnostic contract instead of ad hoc panic strings. +- Added broad runtime coverage for wrapped panic formatting, suppression behavior, recovery-versus-rethrow policy, SSR panic handling, hydration and deferred panic reporting, and propagation into devtools snapshots and browser-visible logging. +- Updated docs with a formal fatal panic log contract, new actionable error codes for server and tool failures, and explicit recovery-versus-fatal rules so future diagnostic changes stay aligned across runtime, docs, and tooling. + +### First public testing companion surface + +- Added `docs/TESTING.md` to define the intended first-party testing surface as a companion module made of focused helper packages instead of one monolithic core testing API. +- Added the first public `testkit/render` fixture for `js/wasm` tests with controlled mock-DOM rendering, rerendering, accessibility-first role and name queries, lower-level id/text/tag queries, synthetic event dispatch helpers, and deterministic scheduler settlement helpers. +- Added `testkit/hooks` with a lightweight `RenderHook(...)` harness so hook-driven state flows can be exercised without writing a bespoke host component for every wasm-side test. +- Added `testkit/router` with hash and history fixtures that support route registration, initial path setup, navigation, params and query inspection, and delegated rendered-route assertions from public APIs. +- Added `testkit/ssr` with snapshot helpers, typed bootstrap-payload assertions, and a lightweight hydration smoke harness so SSR and hydration paths can be tested from public entrypoints instead of repo-local fixtures. +- Added consumer-oriented example tests and direct coverage for each of the new testkit packages so the shipped surface is documented by working test patterns rather than only by API signatures. + +### Example and tool error reporting + +- Added a small public `diagnostics` package over the internal reporting helpers so example servers and tools can emit the same structured actionable reports used by the runtime. +- Updated several SSR and server-integrated examples to return structured request and startup failures with stable codes, runtime consequences, remediation guidance, and docs anchors instead of plain `panic(...)` or raw `http.Error(...)` responses. +- Updated the live-reload tool to emit structured diagnostics for watcher failures, websocket delivery problems, client-script injection errors, manifest generation issues, rebuild failures, and startup problems so hot-reload breakage is easier to interpret from the terminal and browser. +- Extended devtools snapshot structures and UI summaries to retain wrapped panic metadata such as top frame and runtime consequence, keeping in-app inspection aligned with the new fatal panic contract. + +## 2026-03-20 + +### SSR observability hooks + +- Added a focused SSR observability surface in `ui` through `ObserveSSR(...)` plus observed render and bootstrap helpers so applications can capture request-level render timing, bootstrap payload sizes, and inline bootstrap script sizes without adopting a framework-specific logger backend. +- Extended browser hydration instrumentation to report per-hydration duration, existing DOM counts, mismatch counts, fallback counts, and discarded-node counts, with optional correlation ids threaded from `ui.Hydrate(...)` options into the emitted observation. +- Added native and runtime coverage that verifies render observations, bootstrap size metrics, and hydration fallback summaries are emitted from the shipped public surface. + +### State transfer contracts and update envelopes + +- Extended `ui.SSRBootstrap` and `ui.SSRBootstrapReference` with explicit schema versions and decode-time validation so newer payload schemas are rejected instead of being silently misread by older clients. +- Added typed state-transfer helpers in `ui` for route data, form defaults, cache seeds, session hints, scoped payload inspection, and non-JSON-friendly payload encoding for bytes, time values, text-marshaled ids, and explicit CBOR payloads. +- Added `ui.SSRStateUpdate` plus JSON and CBOR encode/decode helpers so post-hydration server-to-client payload refreshes can use versioned text or binary update envelopes instead of replacing the full bootstrap payload. +- Added `ui.AnalyzeSSRBootstrapSize(...)` so applications can measure inline JSON, inline script, and CBOR payload sizes and choose between inline, sidecar JSON, or sidecar CBOR transport with explicit warning bands. + +### Wasm build experiment tooling and release-size comparison + +- Added repeatable wasm build experiment helpers for phase-attributed timing, cache-topology comparison, CI-friendly manifest comparison, and explicit Go toolchain comparison so build-speed and artifact-size decisions can be made from saved JSON results instead of ad hoc shell timings. +- Added a stable representative target set for small, routed mid-sized, and large wasm applications, together with updated build experiment docs and completed backlog tracking for the current measurement surface. +- Extended wasm compression and release tooling with a Node-based Brotli fallback plus `npx --package binaryen wasm-opt` support so gzip, brotli, and optimized-wasm variants can be measured on standard contributor machines even when the host PowerShell runtime lacks Brotli support or `wasm-opt` is not installed globally. +- Recorded the current accepted and rejected build-optimization outcomes in the docs, including the stripped release baseline, gzip release sidecars, cache-behavior guidance, and the still-not-default status of Brotli and `wasm-opt` until the saved comparison results justify promoting them. + +### Fine-grained reactivity and subscribed-region updates + +- Added explicit fine-grained subscribed-region support on top of the existing fiber runtime through reactive text nodes, general reactive regions, selector-backed shared projections, and transition-aware shared-state update paths. +- Narrow subscribed updates can now update stable text nodes, host properties, and small anchored host-only subtrees without rerendering the owning component, while hook-driven rerenders still take precedence when mixed ownership would otherwise be ambiguous. +- Expanded runtime inspection and devtools snapshots with fine-grained fiber counts, granular mark and commit counters, and per-node update-origin or reactive-source metadata so narrow updates are visible in diagnostics instead of appearing as generic dirty work. +- Added deeper runtime, wasm, SSR, benchmark, and Playwright coverage for subscribed-region behavior, selector stability, transition deferral, hydration reuse, ancestor-rerender costs, and browser-level non-rerender guarantees. +- Added `docs/FINE_GRAINED_REACTIVITY.md` plus related roadmap and performance updates so the current mixed-model contract, measurements, and limits are documented as part of the repo history. +- Followed up with targeted rerender-path optimization passes that removed the measured ancestor-rerender overhead for the current stable-region benchmark shape by reusing unchanged reactive-source bookkeeping and redirecting stale subscribed fibers to their live fine-grained twin instead of transferring ownership during every clean clone. +- Expanded profiling and devtools visibility further with descendant host and descendant text commit counters inside fine-grained regions, plus regression coverage that proves stale subscribed twins still resolve to the live current region after ancestor rerenders. + +## 2026-03-18 + +### Browser interop and multipart workflows + +- Added a new public `interop` package with typed wrappers for browser storage, history, location, clipboard, timers, custom and generic event listeners, document lookup, element handles, resize observers, intersection observers, media queries, and dynamic module import. +- Added structured interop error handling through `interop.Error`, `IsCode(...)`, `AsError(...)`, and `CodeOf(...)`, together with native and `js/wasm` test coverage for browser-only failure paths and wrapper behavior. +- Added multipart request support to `fetch` through `MultipartBody`, `MultipartFile`, and `Upload(...)`, including progress updates, cancellation, preserved response status and headers, and structured HTTP error reporting for non-success responses. +- Added public browser file helpers in `ui` so file inputs and upload flows can work through typed `ui.File` wrappers instead of raw `syscall/js` values. + +### SSR forms and server-integrated application flows + +- Added the `87-ssr-secure-forms` example to demonstrate request-time SSR form rendering, CSRF-aware form posting, multipart upload validation, server round-trips that preserve user input, and post-submit `303 See Other` redirects. +- Added stronger `ui` form support for server-driven workflows, including server-error shaping, request-targeted submit modes, CSRF naming helpers, and typed file helpers on both browser and native targets so SSR form code no longer has to hand-roll those pieces. +- Added focused tests and microbenchmarks for secure SSR form rendering and multipart upload handling, plus wasm-side fetch and interop benchmarks for multipart form-data creation and browser interop calls. +- Added the first Atlas Commerce OS server-integrated workflow pass with request-time rendering, mock session routing, CSRF protection, SQLite-backed read and mutation flows, bootstrap payloads, startup migrations, and dedicated SSR browser coverage. + +### Documentation and adoption guides + +- Added `docs/START_HERE.md`, `docs/FORMS.md`, `docs/WORKFLOWS.md`, `docs/WALKTHROUGHS.md`, `docs/TROUBLESHOOTING.md`, and `docs/REFERENCE_MAP.md` to give new adopters a task-oriented route through the current public package surface. +- Expanded the docs index and migration guidance so the current public package surface, SSR and form workflows, troubleshooting path, and reference-app adoption path are linked from one consistent set of entry documents. +- Added dedicated Atlas Commerce OS documentation, layout maps, screenshots, and server notes so the reference application is documented as a real server-integrated workflow instead of only as runnable code. +- Added `interop/README.md` and refreshed `fetch` and docs index guidance so multipart upload, SSR form, and browser interop workflows are documented from the public API perspective instead of requiring commit archaeology. + +### Browser platform integration and runnable examples + +- Expanded `interop` with first-class worker helpers, typed worker request/progress/result envelopes, cross-tab channels with `BroadcastChannel` and `storage` fallback, popup/opener window channels, multi-surface signals, and additional typed browser wrappers so common browser coordination flows no longer require ad hoc `syscall/js`. +- Added `html.CustomElement(...)` and related custom-element guidance so browser-defined web components can be consumed with explicit attribute, presence-attribute, and property mapping instead of raw prop spreading. +- Added explicit mount-target APIs through `ui.RenderInto(...)` and `ui.HydrateInto(...)`, plus the `ui.UseWorkerTask[...]` hook for binding worker-backed browser jobs into normal component state. +- Added `examples/public/web-components`, `89-exported-custom-element`, `90-browser-interop`, `91-worker-text-index`, `94-cross-tab-sync`, and `95-multi-window-console` to demonstrate third-party custom elements, export-side web-component prototypes, typed browser interop, worker-backed CPU-heavy UI, cross-tab sync, and multi-window coordination. + +### Cache reuse, auth-routing, and offline workflows + +- Expanded `fetch.UseCachedResource[T]` with cache freshness and disposal policies, imperative `LoadCached(...)`, cache inspection, SSR bootstrap restore, resume-policy handling, and route-loader interoperability so shared data reuse works across component, loader, and SSR resume flows. +- Added a durable browser-backed offline mutation queue through `fetch.OpenMutationQueue(...)` with replay, deduplication, retry scheduling, dead-letter state, and wasm-side tests for replay and cancellation behavior. +- Added safe post-auth redirect helpers in `router` for preserving and validating internal `return_to` targets, and added the `92-protected-routes` and `93-ssr-cache-bootstrap` examples to demonstrate protected navigation, shared cache reuse, and SSR-seeded cache hydration. +- Added cache, offline mutation, auth-routing, observability, and server-integration documentation so the current routed-app and shared-data model is described as a public contract instead of only through tests and examples. + +### Hydration diagnostics, runtime hardening, and devtools + +- Hardened hydration and recovery with component-stack-aware mismatch diagnostics, opt-in strict hydration mode, preserved browser-owned form control state during the initial reuse pass, and explicit docs for hydration behavior, state transfer, streaming SSR boundaries, and mismatch recovery. +- Expanded runtime diagnostics to record structured classifications, buffered framework logs, and component path/stack context for recovered boundary errors, and surfaced those logs and diagnostics through the devtools snapshot and panel. +- Added broader runtime correctness and benchmark coverage, including production-correctness scenarios, hydration reuse and fallback benchmarks, and transition scheduling benchmarks, while also keeping the `production` wasm utils surface aligned with development exports. +- Refreshed `examples/public/transition-hooks` into a more realistic transition-style UX example and aligned the backlog/docs around the current runtime, scheduling, error-boundary, and hydration behavior. + +### Tooling, release engineering, and platform policy docs + +- Added `tools/build-wasm-release.ps1` and a sample wasm size-budget file so release-style builds can emit stripped artifacts, gzip sidecars, hashes, manifests, and optional size-budget enforcement from one helper. +- Added docs covering cache behavior, custom elements, interop, workers, cross-tab sync, multi-surface coordination, error boundaries, production correctness, scheduling, hydration, streaming SSR, server integration, observability, logging, prerender, assets, browser support, PWA boundaries, security, configuration, wasm releases, build experiments, and onboarding. +- Updated example indexes, manual-testing guidance, and docs entrypoints so the newer example set and system-level docs are discoverable from the top-level navigation. +- Ignored the repo-local `.gotmp/` Go temp/build directory so local release-build and wasm test artifacts stop appearing as worktree noise. + +## 2026-03-16 + +### Internationalization and localization + +- Added a new public `i18n` package with `UseLocale(...)`, `Provider(...)`, `UseI18n()`, deterministic bundle registration, missing-message fallback behavior, interpolation, pluralization, select-style branching, and locale-aware number or date formatting helpers. +- Added route-oriented helpers `PrefixPath(...)` and `ResolvePath(...)` so locale prefixes can stay application-owned without pushing locale policy into `router` itself. +- Extended `ui.SSRBootstrap` with typed `I18n` payload support and bundle conversion helpers so server-rendered pages can transfer active locale, fallback locale, direction, and the initial message subset used during hydration. +- Added `docs/I18N.md` to define the current i18n scope, SSR transfer model, locale-aware routing guidance, and RTL or directionality expectations. +- Added `examples/public/locale-switcher`, `examples/public/server-side-rendering-internationalization-bootstrap`, and `examples/public/locale-routing` together with focused Playwright coverage for runtime locale switching, bootstrap-driven locale hydration, and locale-prefixed loader-driven routing. +- Added native `i18n` tests and a translation microbenchmark covering fallback lookup, pluralization, formatting, SSR bootstrap round-tripping, and locale-aware path helpers, plus `ui` bootstrap tests that assert the new `I18n` payload is serialized and initialized correctly. + +### Portal layering and overlay management + +- Added `ui.Overlay(...)` and `ui.UseOverlayStack(...)` for shared overlay layering, stack-derived z-order, nested escape and outside-click routing, and coordinated focus ownership across portal-backed surfaces. +- Updated `ui.AccessibleOverlay(...)` to compose on top of the shared overlay stack instead of wiring instance-local modal behavior independently. +- Updated overlay side effects to support nested scroll-lock counting and nested background inert ownership by app-root selector. +- Added `docs/OVERLAYS.md` to document the current overlay layering model, dismissal routing, and anchored-position guidance. +- Added `examples/public/overlay-stack` and `examples/82-overlay-anchor` together with focused Playwright specs covering nested dialogs, dialog-plus-popover routing, tooltip-over-menu layering, and portal retargeting. +- Added stack-manager coverage in `ui` tests so topmost escape handling, outside-dismiss routing, focus-trap ownership, and derived z-index behavior are validated directly. + +### Accessibility guidance baseline + +- Added `ui.UseFocusManager()`, `ui.UseFocusTrap(...)`, `ui.UseCompositeNavigation(...)`, `ui.UseAnnouncer()`, and `ui.AccessibleOverlay(...)` as the first public accessibility-focused primitives. +- Expanded `docs/ACCESSIBILITY.md` to document the shipped accessibility model for focus restoration, modal overlays, composite keyboard navigation, live-region announcements, forms, route changes, and async UI. +- Added baseline and API-level tests covering accessible prop preservation, `ui.UseId()` behavior, composite navigation keyboard flow, and live-region rendering. +- Added focused accessibility examples for modal overlays, composite widgets, form validation announcements, and routed page announcements, together with Playwright browser coverage. + +### Head management and SEO guidance + +- Added `docs/HEAD_MANAGEMENT.md` to define the current head-management model, including the boundary between router-managed metadata and application-owned explicit SEO markup. +- Documented canonical URL policy, structured-data guidance, resource-hint guidance, social metadata examples, and sitemap or robots integration expectations for the current SSR surface. +- Added tests covering managed head-tag deduplication after hydrated startup and SSR output checks that enforce a single managed title, description, and canonical tag set. + +### Metadata model and composition policy + +- Added `router.MetadataNode(...)` so route-managed title, description, and canonical tags can be rendered during SSR through `ui.RenderToString(...)`. +- Updated client router metadata reconciliation to treat SSR and client navigation as one managed metadata flow, reusing and cleaning up only router-owned head tags. +- Updated the SSR server-routing example to render managed metadata tags through the shared router helper instead of hand-built escaped strings. +- Documented the current composition decision that slots are out of scope in favor of ordinary children, explicit props, context, portals, and layout routes. + +### API policy and migration guidance + +- Added `docs/API_POLICY.md` to define public API stability tiers, semver expectations, deprecation timing, breaking-change rules, and current latest-major-only support policy. +- Added `docs/MIGRATIONS.md` as the release-to-release migration index, starting with guidance for moving into the current `v3.x` public package layout. +- Linked the new policy and migration docs from the root README and docs index. +- Updated the documentation backlog to mark the API stability and support policy work complete. + +### Example catalog and backlog alignment + +- Expanded the feature example catalog so the examples index and shared catalog copy map the shipped examples more directly to the current public APIs and learning goals. +- Refreshed the root README and docs backlog structure around the current public package surface, numbered roadmap sections, and completed-work tracking instead of leaving newer example and docs work scattered across older notes. +- Added the first Atlas Commerce OS planning backlog so the larger reference-application effort has an explicit timeline in the repo instead of only appearing through implementation commits later. + +## 2026-03-15 + +### Runtime optimization work + +- Reduced `GoUseFunc(...)` validation overhead with build-specific fast paths for common function signatures. +- Reduced `GoUseAtom(...)` overhead by storing atom values directly, adding a single-subscriber notification fast path, and caching getter/setter accessors per hook slot. +- Added keyed-reconciliation fast paths, pooled keyed scratch state, and lower-overhead keyed-child consumption to reduce keyed list churn. +- Cached DOM prop metadata in `updateDomProperties(...)` and added a steady-state DOM property benchmark path. +- Cached additional jsdom document query bindings and switched DOM collection traversal to indexed access instead of `item(...)` calls. +- Added runtime layout and keyed reconciliation benchmark coverage used to validate and reject broader cache-layout experiments. +- Reverted broader experiments that regressed the benchmark suite, including the hot/cold `Fiber` split and a dedicated non-batching initial DOM-props fast path. + +### Runtime correctness fixes + +- Fixed function-component deletion so removing one DOM-less component subtree does not incorrectly remove sibling component DOM. + +### SSR and hydration groundwork + +- Added the first internal SSR render-to-string path for host elements, text nodes, fragments, and simple function components. +- Added public server-side rendering support through `ui.RenderToString(...)` on non-browser targets. +- Added a dedicated `Hydrate(...)` and runtime `HydrateTo(...)` entrypoint so client resume now has a real API path instead of reusing plain render calls. +- Upgraded hydration from whole-container fallback to real DOM reuse for matching host and text nodes, with subtree-level fallback when structure matching fails. +- Added hydration mismatch diagnostics for text, tag/structure, trailing-node, and critical attribute differences, with clear warn-versus-replace behavior. +- Added bootstrap-time atom snapshot restore and ID-seed application so hydration resumes shared state and `UseId` generation from the transferred SSR payload. +- Deferred hydration-time atom subscriptions and follow-up update notifications until the hydration commit completes, then ran effects against the committed tree. +- Added safe SSR bootstrap helpers for inline JSON payloads, including script-tag rendering and browser-side bootstrap-script reading. +- Added optional CBOR-based binary bootstrap encoding/decoding for SSR payload transport. +- Added sidecar bootstrap reference support so hydration can load external JSON or CBOR bootstrap payloads instead of only inline script JSON. +- Added SSR/bootstrap and hydration tests covering DOM reuse, subtree fallback, text mismatch recovery, trailing-node cleanup, bootstrap atom restore, and ID-seed resume behavior. +- Added SSR transport microbenchmarks showing CBOR bootstrap encode/decode is materially cheaper than JSON for larger sidecar-style payloads in the current implementation. + +### Public package and wasm tests + +- Added wasm-facing public package tests for `html`, `ui`, `state`, and `fetch` wrappers. +- Expanded HTML builder coverage to verify public prop preservation, wrapper tag selection, and text/fragment helper behavior. +- Added public wrapper coverage for `state.UseComputed`, `fetch.UseResource`, `ui.UsePrevious`, `ui.UseChannel`, and `ui.UseTask`. +- Added public wrapper coverage for `ui.UseReducer`, `ui.UseForm`, `state.UseDerived`, and state snapshot persistence helpers. + +### Public hooks and state ergonomics + +- Added `state.UseComputed[T]` as a typed derived-state helper on top of the memoization runtime. +- Added `state.UseDerived[T]` as a read-only shared derived-atom helper with explicit source-atom dependencies. +- Added state snapshot export/import and browser storage persistence helpers for same-process restore and JSON-compatible saved state. +- Added `fetch.UseResource[T]` for typed async loading with cancellation, reloads, and typed ready/error state. +- Added `fetch.UseCachedResource[T]` with shared keyed cache state, in-flight request deduplication, stale-while-revalidate refreshes, invalidation, and optimistic update helpers. +- Added `ui.UsePrevious[T]`, `ui.UseChannel[T]`, and `ui.UseTask[T]` to cover render-time comparisons, channel-driven UI streams, and explicit cancellable background jobs. +- Added `ui.UseReducer`, `ui.UseForm`, `ui.UseDebounced`, and `ui.UseThrottled` to cover reducer-style local state, structured form lifecycle handling, and delayed/rate-limited derived UI values. +- Added `ui.StartTransition`, `ui.UseTransition`, and `ui.UseDeferredValue` as the first concurrent-style scheduling primitives for non-urgent tree refreshes and lagging derived values. +- Added `ui.AsyncBoundary`, `ui.UseLazyNode`, and `ui.Lazy` as the first explicit async UI primitives for fallback rendering, deferred subtree resolution, and timeout-aware loading boundaries. +- Added `ui.ErrorBoundary` as a runtime-recognized subtree recovery wrapper with fallback rendering, explicit reset support, and server/client parity for render-time panic recovery. + +### Router fixes and tests + +- Normalized router default routes, registration paths, and navigation targets so hash/history routing behaves consistently across trailing-slash and hash-prefixed inputs. +- Hardened browser-router setup against missing browser globals in wasm test environments. +- Added wasm browser-environment test helpers and broader router wasm test coverage for navigation, registration, and normalized default-route behavior. +- Added route patterns, typed `UseParams`, `UseQuery`, and `UseNavigate` helpers, plus query-aware path normalization for hash and history routing. +- Added route-level loaders with route-scoped loading/error renderers, cancellation on navigation changes, and route+query keyed revalidation. +- Added `UseRouteData`, `UseRevalidator`, and manual current-route revalidation support with router tests for params, query parsing, loaders, cancellation, and explicit reruns. +- Added route option support for titles, declarative redirects, synchronous `BeforeEnter`/`BeforeLeave` guards, and route-managed description/canonical metadata with cleanup on route changes. +- Added nested layout routes through `router.Options{Layout: true}` and explicit child rendering through `router.Outlet()`. +- Added nested route-stack resolution so parent layout routes render from shallowest matching prefix to the final leaf route, with parent params scoped per level and leaf routes receiving the final merged param set. +- Extended nested routing support across hash and history routers, including layout-aware guard evaluation and per-route loader-data scoping during nested rendering. +- Expanded router edge-case coverage for decoded params, unsupported optional-segment syntax, exact-vs-pattern precedence, blocked navigation, redirected navigation, and metadata replacement/cleanup semantics. +- Added nested layout route tests covering outlet rendering, per-level params, per-level route data, leaf-metadata precedence, nested redirects, `InspectCurrentRoute()`, and history-router nested guard behavior. +- Added router microbenchmarks for nested route-stack resolution, nested `Current()` rendering, and nested navigation evaluation baselines in the js/wasm test lane. + +### Devtools and inspection + +- Added a new public `devtools` package with runtime snapshot capture and an embeddable in-browser inspector panel. +- Added committed component tree inspection, hook summaries, route inspection, and runtime totals to the new devtools surface. +- Added structured diagnostics for invalid hook usage, missing render targets, duplicate route registration, and invalid route component configuration. +- Embedded the devtools panel into the `14-omi` showcase example. +- Added baseline profiling counters for renders, scheduled updates, work-loop passes, processed units, commits, and last render/commit timings. +- Added structured missing-key diagnostics for mixed keyed/unkeyed sibling lists. +- Added runtime error-boundary recovery for render, effect, cleanup, and event-handler panics together with diagnostics and follow-up rerender scheduling. +- Added a smaller standalone `16-devtools` example focused on the public devtools package. + +### Example upgrades + +- Reworked the goroutine example around `ui.UseTask` and `ui.UseChannel`, replacing manual task bookkeeping and adding a streamed channel-driven UI panel. +- Reworked the fetch example around `fetch.UseResource[T]` with typed list/detail loading, explicit retry controls, and cancellation. +- Reworked the fetch example further around `ui.AsyncBoundary` and `ui.Lazy`, replacing manual loading-branch plumbing with explicit async subtree boundaries and a deferred auxiliary panel. +- Reworked the fetch example again around `fetch.UseCachedResource[T]`, shared query reuse, key-based invalidation, and optimistic detail/list updates. +- Updated the atoms example to demonstrate `state.UseComputed` for derived labels and summaries. +- Updated the text-input example to demonstrate `ui.UseDebounced` and `ui.UseThrottled` with visible delayed preview and throttled count feedback. +- Reworked the advanced-form example around `ui.UseForm`, async validation, retryable submission, and router-driven success flow. +- Expanded the OMI example with nested route navigation, loader-backed detail/search/protected routes, and manual route revalidation controls. +- Added the `19-nested-routes` example to demonstrate dashboard and docs layout shells, nested settings layouts, explicit outlet composition, and nested param-driven leaf routes. + +### Documentation refresh + +- Aligned the `fetch` package docs and examples around `UseFetch` as the low-level raw hook and `UseResource[T]` as the preferred typed async resource API. +- Extended the `fetch` docs to cover `UseCachedResource[T]`, shared cached queries, optimistic updates, and async-boundary integration. +- Rewrote the `router` package docs to match the current public API, including params, query helpers, loaders, and manual route revalidation. +- Expanded router docs to cover layout-route registration, `router.Outlet()`, nested route matching rules, and per-layout route-data behavior. +- Refreshed portfolio and showcase copy to use the current `UseState`/`UseEffect`/`UseMemo` and `UseFetch`/`UseResource` naming instead of stale legacy names. +- Expanded `state` and `ui` docs to cover typed computed state, previous-value tracking, channel subscriptions, and cancellable tasks. +- Documented the transition/deferred-value scheduling model and the current decision to avoid a dedicated layout-effect hook until concrete DOM-read-before-paint cases appear. +- Expanded `ui` docs further to cover the new `ErrorBoundary` contract, fallback callbacks, and explicit reset behavior. +- Added docs for shared derived state, snapshot persistence, route guards, route-managed metadata, reducer/form helpers, and debounced/throttled UI hooks. +- Updated the backlog and examples index to mark nested routes and layout routes complete and list the new multi-level example. +- Expanded the root README with a project-wide feature inventory, clarified the stable public package surface, and brought the shipped examples list up to the current `16` through `19` demo set. +- Refreshed the SSR demo and README copy so the examples describe the shipped hydration behavior accurately: bootstrap restore, matching DOM reuse, and subtree fallback on structural mismatch. + +### Browser tests and benchmarks + +- Expanded Playwright integration coverage for filtered todo flows, effect cleanup under broader app activity, and mixed local/shared-state burst interactions. +- Added Playwright coverage for debounced/throttled text input behavior, advanced-form validation/retry/success flow, and the standalone devtools example. +- Added jsdom wasm benchmarks for `GetElementById(...)` and `QuerySelectorAll(...)` and refreshed the React-vs-Go browser benchmark run. + +## 2026-03-14 + +### Runtime fixes + +- Fixed function-component reconciliation so components that return `nil` correctly delete previously rendered children. +- Fixed DOM-less subtree deletion so all descendant sibling DOM branches are removed during unmount. +- Fixed stale hook ownership on reused/skipped function components so later stateful updates target the correct fiber. +- Fixed `GoUseState` so nil-able state types can be reset with `set(nil)`. +- Fixed `GoUseAtom` so nil-able atom state types can be reset with `set(nil)`. +- Fixed `GoUseAtom` initialization on fresh component fibers so global atom hooks work on first use. +- Fixed scheduler update propagation so clean ancestors are marked even when a leaf is already dirty. +- Fixed global runtime initialization so `InitGlobalRuntime()` can upgrade a lazily created global runtime. +- Fixed HTML component helper wrappers so component refs are wrapped as component elements instead of being passed as raw children. +- Removed the artificial `50ms` delay from the wasm fetch hook. +- Removed runtime debug logging from the wasm fetch hook. +- Completed the runtime event wrapper so `GoEvent` exposes target and key-code access and safely handles missing event methods. +- Optimized `Text()` shim output to use the text-element layout directly. +- Normalized the native fetch stub error and removed per-call closure allocation from the stub implementation. + +### Runtime optimization work + +- Added work-in-progress fiber reuse through alternates in the reconciler and scheduler. +- Added batched atom unsubscription with `UnsubscribeMany(...)` to reduce lock churn during cleanup. +- Optimized component helper child creation in `html.go` to avoid unnecessary wrapper overhead. +- Specialized `WASMDOMAdapter.WrapFunction` so callback dispatch type selection happens once at wrap time instead of on every invocation. +- Kept only measured low-risk optimizations and reverted regressions found during benchmark runs. + +### Runtime tests + +- Added contract-focused reconciler tests. +- Added extra hooks contract and edge-case tests. +- Added scheduler contract and edge-case tests. +- Added atom state contract and cleanup tests. +- Added runtime global-init and render contract tests. +- Added HTML helper contract tests. +- Added wasm fetch hook tests. +- Added wasm event adapter tests. +- Added shim tests for global wrapper behavior. +- Added interfaces contract tests and compile-time adapter assertions. +- Added exhaustive native runtime coverage tests and raised native `internal/runtime` statement coverage to `100%`. + +### Browser component and integration tests + +- Added Playwright component tests for local state isolation, rerender stability, effect cleanup, and `UseId` behavior. +- Added Playwright integration tests for todo flows, shared atom propagation, theme updates, fetch flows, and form handling. +- Added deep state stress tests covering `5+`, `25+`, `100+`, repeated burst updates, mixed local/shared state, and rerender persistence. +- Added test app components to exercise stress and mixed-state scenarios. +- Added mock API and test server endpoints needed by the browser suites. + +### Benchmarks + +- Added runtime microbenchmarks for reconciler hot paths. +- Added hooks microbenchmarks. +- Added scheduler microbenchmarks. +- Added atom state microbenchmarks. +- Added runtime wiring microbenchmarks. +- Added HTML helper microbenchmarks. +- Added shim microbenchmarks. +- Added native fetch stub microbenchmarks. +- Added `types.go` microbenchmarks. +- Added wasm adapter boundary benchmarks for DOM operations and callback wrapping. + +### Benchmark tooling and reporting + +- Fixed the browser benchmark harness and added a runtime update regression test to catch render/update performance regressions. +- Added benchmark build and inspection scripts for the browser benchmark suite. +- Documented the current browser benchmark results in the project documentation. + +### Public API and examples + +- Introduced the typed `ui` and `html` public APIs and started moving examples onto the new surface. +- Added the `14-omi` showcase example. +- Added the `15-calculator` interactive calculator example with engine, UI, and presets. +- Updated the examples index and static landing page wiring for the new showcases. + +### Documentation refresh + +- Refreshed the root README to reflect the current runtime architecture, test status, public package guidance, and install/build instructions. +- Updated browser compiler and project docs to match the current repo layout and tooling. + +### Tooling and developer workflow + +- Rebuilt the development server around Node/Express and saved it in `tools/dev-server/`. +- Added dynamic `/examples` listing based on the filesystem instead of hard-coded routes. +- Updated server scripts and tooling docs to use the new development server. +- Added a wasm test execution helper in `tools/go_js_wasm_exec.bat`. +- Added new test scripts for component, integration, and state browser test layers. +- Added a GitHub Pages deployment workflow for the examples site and a generated redirect page for the published showcase. +- Upgraded CI workflows to current `checkout`, `setup-go`, and `setup-node` action majors. +- Upgraded CI to Go `1.25.4` and Node `24`. +- Stabilized flaky Playwright hook/browser tests by replacing transient timing assertions with stable result checks and stronger selectors. +- Tracked the Playwright test lockfile, added npm caching for the test package, and split CI dependency install, browser install, and test execution into separate steps. +- Fixed automated release version calculation so semantic releases continue from the latest `vX.Y.Z` tag instead of resetting to `v0.0.x`. + +### Validation status + +- `go test ./internal/runtime` passes. +- Native `internal/runtime` statement coverage is `100%`. +- Browser component, integration, and deep state stress suites pass. +- Wasm runtime and adapter tests pass in the separate `js/wasm` test lane. +- The examples site deploys through the GitHub Pages workflow. +- The `CI + Release` workflow passes on `master`. +- Automated semantic release tagging resumed and published `v3.0.3`. + +## 2025-11-26 + +### Browser compiler experiment + +- Moved the in-browser compiler experiment into its own more self-contained example flow under `examples/public/browser-compiler`. +- Added the supporting browser-compiler scripts, package index generation flow, and bundled `js/wasm` standard-library assets needed to run that experiment from the repo. + +## 2025-11-19 + +### Runtime architecture and performance + +- Reworked the runtime architecture and aligned the examples with the updated rendering and hook model. +- Optimized reconciliation and rendering hot paths across the runtime and jsdom adapter layers. +- Fixed the goroutines example so background-driven UI updates render correctly. + +### Benchmarks and test structure + +- Added a browser performance benchmark app and Playwright benchmark coverage, and restructured the broader test layout around that workflow. +- Expanded runtime and reconciliation coverage while tightening test expectations around hook/fiber behavior. +- Fixed advanced hash-router test behavior around navigation history and visibility-driven cases. + +### CI and release workflow + +- Added the initial CI/CD workflow and refreshed the project README with workflow badges and updated project assets. +- Iterated on CI reliability by excluding unsuitable benchmark/unit-test paths, switching browser-test dependency install behavior, and wiring E2E web-server startup on port `8081`. +- Scoped CI browser coverage away from portfolio-site cases that required a separate examples server. + +### Examples, docs, and site polish + +- Refined the portfolio-site presentation, including the 3D showcase card rendering issues and updated hero-image assets. +- Added license and example coverage for pkg.go.dev across the public packages. + +## 2025-11-18 + +### WASM runtime and fetch groundwork + +- Added early WASM runtime improvements centered on a new fetch hook path and lower-level function-wrapping support. +- Updated the jsdom/mockdom adapter and runtime shim layers to support that browser-focused hook flow. +- Added early browser test coverage for events, hooks, and reconciliation rerender behavior using the test app fixtures. + +### Documentation cleanup + +- Cleaned up the root README formatting and readability before the larger runtime and tooling changes that followed. + + diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000..7875bf21 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,179 @@ +# Contributing to GoWebComponents + +This guide is for people working **on the framework** (its packages, runtime, +and tooling). If you are building an app *with* GoWebComponents, start with the +[Getting Started chapter](docs/REFERENCE_MANUAL/01-getting-started.md) and the +[gwc workflow guide](docs/REFERENCE_MANUAL/02-gwc-workflows.md) instead. + +## Prerequisites + +- **Go 1.26+** (`go version`; matches the `go` directive in `go.mod`). +- A browser with WebAssembly support for the browser test lanes. +- The `gwc` launcher is run straight from source: `go run ./tools/gwc `. + +Run `go run ./tools/gwc doctor` first — it checks the toolchain, the +`wasm_exec.js` runtime asset, and browser-test prerequisites and prints fix +hints for anything missing. + +## Editor setup (read this first) + +Most of the framework's browser code is in files guarded by +`//go:build js && wasm`. A Go language server analyzing for your host OS will +**hide every wasm-tagged file** and show phantom errors across the whole +browser half of the codebase. + +This repo commits `.vscode/settings.json`, which pins `gopls` to +`GOOS=js GOARCH=wasm` so the wasm files resolve. The trade-off is that +native-only files (SSR, the `gwc` tool, native stubs) are then the excluded +set — flip the env back to host values temporarily when working on those, or +open that package in a separate window. JetBrains users: set the same +`GOOS=js`/`GOARCH=wasm` in the Go build tags / environment for the project. + +## Build + +```powershell +# Native (tooling, SSR, native stubs) +go build ./... + +# Browser (the wasm build the framework actually ships) +$env:GOOS='js'; $env:GOARCH='wasm'; go build ./...; Remove-Item Env:GOOS; Remove-Item Env:GOARCH +``` + +Bash equivalent for the wasm build: `GOOS=js GOARCH=wasm go build ./...`. + +A change to public API should build under **both** targets. Many packages have a +`*_wasm.go` / `*_native.go` split; keep the exported surface identical across +the two so callers compile on either target. + +## Testing + +### Native tests + +```powershell +go test ./... +``` + +### WASM unit tests (the "wasm dance") + +`go test` cannot run a `js/wasm` binary directly. Compile the test to a `.wasm` +and run it under the Node wasm shim that ships with the Go toolchain: + +```powershell +$env:GOOS='js'; $env:GOARCH='wasm' +go test -c -o pkg.wasm ./ui +node "$(go env GOROOT)/lib/wasm/wasm_exec_node.js" pkg.wasm -test.run=TestName +Remove-Item Env:GOOS; Remove-Item Env:GOARCH +``` + +The launcher wraps this for you: + +```powershell +go run ./tools/gwc test -lane unit -lane wasm -lane hydration -lane browser +``` + +### Browser (Playwright-Go) tests + +Browser suites live under `test/playwrightgo/` and example suites under +`test/playwrightgo/examples/`. They are gated behind the `playwrightgo` build +tag and run real Chromium: + +```powershell +go test -tags playwrightgo ./test/playwrightgo -run TestMainSuite -v +go test -tags playwrightgo ./test/playwrightgo/examples -run TestExamplesAll -v +``` + +### Nested modules + +Some tools are their own Go modules and must be tested from inside them. Most +notably the live-reload server: + +```powershell +go -C tools/livereload test . +``` + +If `go test ./tools/livereload` reports *"main module does not contain +package"*, that is the nested-module signal — use `go -C` instead. + +## Coverage + +```powershell +go test -coverprofile=cover.out ./... +go tool cover -func=cover.out +``` + +For wasm coverage, add `-coverprofile` to the `go test -c` step and run the +compiled binary with `-test.coverprofile`. + +## Conventions + +- **`parse`-prefixed locals.** Every local variable is prefixed `parse` + (`parseKey`, `parseValue`, `parseErr`). See + [docs/CONVENTIONS.md](docs/CONVENTIONS.md) for the full rationale and the + function-naming rules (`verbSubject[Object]`). +- **GoDoc on every exported symbol**, first word = the symbol name. +- **No silent panics.** Browser code recovers at every goroutine and + `js.FuncOf` boundary and emits a structured, agent-readable console report + (crash containment) instead of killing the page. Use `ui.SafeGo(...)` for + goroutines and do not swallow errors just to make a test pass. +- **Keep the public API stable.** `tools/api_compat_guard` pins exported + symbols; additive changes pass, removals fail unless the baseline is + intentionally updated. +- **Docs paths must resolve.** `docs/doclint` fails CI if a fenced command in + any doc references a repo path that no longer exists — fix the doc when you + move an example or package. + +## Windows hazards (the framework is developed on Windows) + +- **CRLF / BOM.** Several assets are embedded via `go:embed` and are + line-ending sensitive. When scripting edits, preserve the file's existing + EOL (the committed `.vscode/settings.json` sets `files.eol` to `\n`). Avoid + PowerShell `Out-File` without `-Encoding utf8` for files other tools read — + it writes UTF-16 with a BOM. +- **`go:embed` and `.gitignore`.** A broad ignore rule can exclude an embedded + asset and break the build only in CI (a clean checkout). If you add an + embedded asset under an ignored path, add a `!` negation and `git add -f` it. +- **Clear stale env before cross-compiling.** If a wasm build behaves oddly, + confirm `GOOS`/`GOARCH` are what you expect — a leftover `GOOS=js` from a + previous shell command silently breaks native builds, and vice versa. + +## Before you open a PR + +```powershell +go build ./... +GOOS=js GOARCH=wasm go build ./... +go vet ./... +go test ./... +go run ./tools/gwc test -lane unit -lane wasm +``` + +Run the relevant browser lane for UI changes, and add a focused Playwright spec +when a regression would otherwise only be caught by eye. + +## Where to ask vs. file + +- **Questions, ideas, "is this a bug?"** → [GitHub Discussions](https://github.com/monstercameron/GoWebComponents/discussions). + Use *Q&A* for help, *Ideas* for proposals, *Show and tell* for what you built. +- **A concrete, reproducible defect** → open an **Issue** with a minimal repro + (the smallest `main.go` + the `gwc` command that reproduces it). +- **A security report** → follow [SECURITY.md](SECURITY.md); do **not** open a + public issue. + +## Triage SLA + +These are the maintainers' good-faith response targets (business days, not a +contractual guarantee — this is a volunteer project): + +| What | First response | Notes | +| --- | --- | --- | +| Security report | **2 business days** | Acknowledgement + triage start. See SECURITY.md. | +| Bug with a repro | **5 business days** | Labeled (`bug`, severity) and routed. | +| Feature / idea | **10 business days** | Labeled and, if accepted, linked to the [roadmap](ROADMAP.md). | +| Pull request | **5 business days** | First review pass; CI must be green first. | + +"First response" means a human has read it and labeled/replied — not that it is +resolved. Stale items with no maintainer reply past these windows may be bumped +by commenting `@maintainers triage`. The label taxonomy and escalation path live +in [GOVERNANCE.md](GOVERNANCE.md). + +The public direction lives in [ROADMAP.md](ROADMAP.md); a feature request that +aligns with a roadmap theme is far more likely to be accepted quickly. diff --git a/GOVERNANCE.md b/GOVERNANCE.md new file mode 100644 index 00000000..bf316ba5 --- /dev/null +++ b/GOVERNANCE.md @@ -0,0 +1,47 @@ +# Project governance + +This document records how decisions are made and how quality is enforced, so the bar is a +process, not a mood. + +## Decision-making + +GoWebComponents is maintainer-led. Changes land through pull requests reviewed against the +rules below; the maintainer is the final arbiter on scope and design direction (see the +reference manual's *Scope And Non-Goals*). Proposals that widen the supported public surface +must come with a clear ownership story that survives the semver policy. + +## What "stand up to scrutiny" means here (the gates) + +Quality is enforced mechanically by checks in the repo, not by reviewer memory: + +- **Public API can't drift silently.** Stable packages carry `api_baseline.txt` golden tests + (`internal/apidump`). Any change to an exported type/func/method/const/var fails CI until + the golden is regenerated *with intent* — which, per [`VERSIONING.md`](./VERSIONING.md), + also decides whether the release is major or minor. +- **Dependency footprint is budgeted.** `gwc supplychain` proves the zero-npm posture, counts + direct/transitive Go deps against a budget, and verifies module checksums. A growth in the + library module's dependency footprint is a reviewable event, not a silent one. +- **Known vulnerabilities are gated.** `gwc vuln` runs govulncheck and fails on a *reachable* + advisory. +- **Every feature ships tested.** Native + wasm where relevant, with e2e coverage on complex + surfaces; the headless story-runner (`workbench.RunStories`) turns examples into smoke + tests. + +## Stability tiers + +Surfaces are **Experimental** or **Stable** (see the reference manual's stability notes). +Experimental surfaces may change without a major bump; graduating one to Stable gives it an +API baseline and brings it under the versioning policy — and is itself a minor release. + +## Contributing + +See [`CONTRIBUTING.md`](./CONTRIBUTING.md) for how to build, test, and submit changes. The +short version: every change is atomic to its feature, carries tests, keeps `go vet` clean, +and updates `CHANGELOG.md`. + +## Structural note + +As a maintainer-led project, the community-governance dimension has a structural ceiling +(there is no multi-org steering committee). The intent here is not bureaucracy but +*legibility*: anyone can read the gates above and predict whether a change is acceptable and +how it will be versioned. diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..3cab65b2 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 MonsterCameron + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index c7ab5d8e..46841671 100644 --- a/README.md +++ b/README.md @@ -1,252 +1,617 @@

- Hero Image + GoWebComponents ChatGPT Hero Image

-# 🚀 GoWebComponents: Empower Your Web Development with Go +# GoWebComponents -## Revolutionize Your Web Stack +[![CI + Release](https://github.com/monstercameron/GoWebComponents/actions/workflows/release.yml/badge.svg?branch=master)](https://github.com/monstercameron/GoWebComponents/actions/workflows/release.yml) +[![Deploy Examples To Pages](https://github.com/monstercameron/GoWebComponents/actions/workflows/pages.yml/badge.svg?branch=master)](https://github.com/monstercameron/GoWebComponents/actions/workflows/pages.yml) +[![Release Version](https://img.shields.io/github/v/release/monstercameron/GoWebComponents)](https://github.com/monstercameron/GoWebComponents/releases) +[![Go Report Card](https://goreportcard.com/badge/github.com/monstercameron/GoWebComponents)](https://goreportcard.com/report/github.com/monstercameron/GoWebComponents) -GoWebComponents brings the power and simplicity of Go to full-stack web development. Combining React-like component architecture with Go's robustness, it offers a unique approach to building high-performance, type-safe web applications. +GoWebComponents is a Go + WebAssembly UI framework with a React-style component model, hooks, a fiber-based runtime, typed HTML builders, shorthand authoring helpers, a typed compile-checked CSS engine, client-side routing, and shared state. It also ships streaming SSR with real async suspension, hydration and static islands, crash containment by default, realtime data hooks, feature flags, i18n, accessibility primitives, and PWA/offline support. -## 🌟 Why Choose GoWebComponents? +It is **batteries-included**: rendering, hooks, routing, shared state, data fetching, SSR/hydration, i18n, accessibility, PWA/offline, feature flags, and devtools all ship in the same Go module, so there is no separate JavaScript build, bundler config, or npm dependency tree to assemble. The trade-offs that come with that — wasm runtime cost and bundle size — are described under [Performance and Trade-offs](#performance-and-trade-offs); read that section before adopting so expectations are set honestly. -1. **Unified Full-Stack Development**: Write both frontend and backend in Go, reducing context switching and enabling seamless type sharing across the entire stack. -2. **Near-Native Performance**: Take advantage of WebAssembly’s performance, running Go code in the browser with speeds close to native execution for computationally heavy tasks. -3. **Strong Typing and Reliability**: Go’s robust type system helps catch errors at compile time, leading to more reliable and maintainable code. -4. **Concurrent UI Handling**: Efficiently manage multiple frontend operations with Go’s goroutines, ensuring smooth, responsive applications without the need for complex concurrency models. -5. **Memory Management with Garbage Collection**: Go’s built-in garbage collector optimizes memory usage in WebAssembly, simplifying memory management compared to manual handling in other languages. -6. **Simplified State Management**: Manage UI and application state directly in Go with a React-like API, eliminating the need for additional state management libraries. -7. **Enhanced Security with WASM**: WebAssembly’s sandboxed execution environment, combined with Go’s security features, provides an extra layer of protection against common web vulnerabilities. -8. **Consistent Development Experience**: Develop, debug, and maintain your entire application stack using Go, creating a streamlined development process and unified debugging experience. -9. **Fast Compilation and Deployment**: Benefit from Go’s quick compile times and its easy integration into WASM, speeding up development cycles and reducing iteration times. -10. **Familiar Component Model**: Utilize a React-like API in Go, easing the transition for developers familiar with React while leveraging Go’s simplicity and efficiency. +It is aimed at teams that want to build browser UI in Go without dropping into a separate JavaScript application stack for rendering, state, routing, and browser lifecycle management. -## 🏗️ Getting Started +## Why GoWebComponents -### Installation +- Write browser UI in Go instead of splitting application logic across Go backends and JavaScript frontends. +- Use a familiar component and hook model for local state, effects, async work, and composition. +- Build DOM trees with typed helpers in `html` or the mixed-argument sugar surface in `html/shorthand` instead of raw string templates. +- Add routing, shared state, fetch helpers, SSR, hydration, and devtools from the same module. +- Validate behavior with native Go tests, js/wasm tests, browser suites, and benchmark coverage already used in this repo. -1. Ensure you have Go 1.22.0 or later installed. -2. Add GoWebComponents to your project: +## Quick Start - ```bash - go get github.com/monstercameron/GoWebComponents@v1.1.0 - ``` +### 30-second golden path -3. Import in your Go files: +Clone the repo and run a real example with rebuild-on-save: - ```go - import "github.com/monstercameron/GoWebComponents/fiber" - ``` +```powershell +go run ./tools/gwc doctor +go run ./tools/gwc dev -app .\examples\public\counter\main.go +``` -### Key Functions +`gwc dev` builds the app to wasm, serves it, and live-reloads on every save. +To scaffold your own app, use `go run ./tools/gwc start` (interactive); the +starter gallery is documented in [docs/STARTERS.md](docs/STARTERS.md). Browse +the example catalog with `go run ./tools/gwc examples`. -Here are the five most essential functions you'll use when building with GoWebComponents: +### Add to an existing module -1. `createElement(typ interface{}, props map[string]interface{}, children ...interface{}) *Element` - - Creates a virtual DOM element. - - Use this to define the structure of your components. +Install the module: -2. `Text(content string) *Element` - - Creates a text node in the virtual DOM. - - Use this for adding text content within elements. +```bash +go get github.com/monstercameron/GoWebComponents@latest +``` -3. `useState[T any](initialValue T) (func() T, func(T))` - - Manages state within a component. - - Similar to React's useState, for creating and updating component-level state. +Import public packages from the module path exactly as declared in `go.mod`: -4. `useEffect(effect func(), deps []interface{})` - - Handles side effects in components. - - Similar to React's useEffect, for performing actions after render or on state changes. +```go +import ( + "github.com/monstercameron/GoWebComponents/css" + "github.com/monstercameron/GoWebComponents/css/u" + "github.com/monstercameron/GoWebComponents/fetch" + "github.com/monstercameron/GoWebComponents/flags" + "github.com/monstercameron/GoWebComponents/hotreload" + "github.com/monstercameron/GoWebComponents/html" + . "github.com/monstercameron/GoWebComponents/html/shorthand" + "github.com/monstercameron/GoWebComponents/router" + "github.com/monstercameron/GoWebComponents/state" + "github.com/monstercameron/GoWebComponents/ui" +) +``` -5. `render(element *Element, container js.Value)` - - Renders a component into a DOM container. - - Typically used to mount the root component of your application. +Requirements: -### Quick Start: Todo List Application +- Go 1.26+ (matches the `go` directive in `go.mod`) +- A browser with WebAssembly support -Let's create a simple todo list to showcase GoWebComponents in action: +The repository root is the module boundary, not a directly importable package. Application code should import public subpackages such as `ui`, `html`, `html/shorthand`, `css`, `css/u`, `state`, `fetch`, `flags`, `router`, `devtools`, and `hotreload`. -```go +The repo-standard workflow uses the `gwc` runner under `tools/gwc`. See [docs/REFERENCE_MANUAL/02-gwc-workflows.md](docs/REFERENCE_MANUAL/02-gwc-workflows.md) for the canonical launcher guide. + +Useful entrypoints: + +```powershell +go run ./tools/gwc doctor +go run ./tools/gwc examples +go run ./tools/gwc dev -app .\examples\public\counter\main.go +go run ./tools/gwc build -app .\examples\public\counter\main.go -profile development +go run ./tools/gwc build -app .\examples\public\counter\main.go -profile debug -out .\bin\debug\counter.wasm +go run ./tools/gwc test -lane unit -lane wasm +go run ./tools/gwc verify -app .\examples\public\counter\main.go -root .\examples\public\counter +``` + +For standalone wasm apps that want state-preserving reload, enable `hotreload.Enable()` in your app and use `gwc dev`. + +## Choose Your Path + +Use these entry docs instead of wandering the tree blindly: + +- Library user: [docs/REFERENCE_MANUAL/README.md](docs/REFERENCE_MANUAL/README.md) and [docs/REFERENCE_MANUAL/01-getting-started.md](docs/REFERENCE_MANUAL/01-getting-started.md) +- Package author working in public APIs: [ui/README.md](ui/README.md), [html/README.md](html/README.md), [state/README.md](state/README.md), [fetch/README.md](fetch/README.md), [flags/README.md](flags/README.md), [router/README.md](router/README.md) +- Framework contributor: [internal/README.md](internal/README.md), [internal/runtime/README.md](internal/runtime/README.md), [internal/platform/README.md](internal/platform/README.md), [internal/runtime2/README.md](internal/runtime2/README.md) +- Tooling contributor: [tools/README.md](tools/README.md), [docs/REFERENCE_MANUAL/02-gwc-workflows.md](docs/REFERENCE_MANUAL/02-gwc-workflows.md), [tools/gwc/docs/README.md](tools/gwc/docs/README.md) +- Example explorer: [examples/README.md](examples/README.md) +- Test or validation work: [test/README.md](test/README.md) and [docs/REFERENCE_MANUAL/12-devtools-testing-and-observability.md](docs/REFERENCE_MANUAL/12-devtools-testing-and-observability.md) + +## Repository Layout + +If you are contributing to the repo rather than just consuming the module, use this map first: + +- `ui/`, `html/`, `html/shorthand/`, `css/`, `css/u/`, `state/`, `fetch/`, `flags/`, `router/`: primary public library packages +- `devtools/`, `head/`, `hotreload/`, `i18n/`, `logging/`, `plugin/`, `prerender/`, `pwa/`, `virtualization/`: companion public packages +- `internal/platform/`, `internal/runtime/`, `internal/runtime2/`: platform adapters and runtime internals +- `testkit/`: reusable consumer-facing test helpers +- `test/`: repo-owned validation suites, fixtures, and browser coverage +- `tools/gwc/`, `tools/livereload/`, `tools/runnerconfig/`: developer tooling and repo automation +- `docs/`: prose documentation and backlog tracking +- `examples/`: examples, showcase apps, and validation fixtures +- `agents/`, `scripts/`: local agent instructions and repository helper scripts +- `third_party/`: pinned external dependencies and cached tool payloads used by this repo +- `bin/`, `log/`: ignored local runtime outputs and local log sinks + +For the fuller human-oriented docs entrypoint, use [docs/REFERENCE_MANUAL/README.md](docs/REFERENCE_MANUAL/README.md). +Local package maps live in the directory READMEs for the larger implementation areas, especially `internal/platform/`, `internal/runtime/`, `internal/runtime2/`, and `tools/runnerconfig/`. + +## Starter App Example + +`main.go`: + +```go gwc:build package main import ( - "fmt" - "syscall/js" - "github.com/monstercameron/GoWebComponents/fiber" + "fmt" + + "github.com/monstercameron/GoWebComponents/css" + "github.com/monstercameron/GoWebComponents/css/u" + . "github.com/monstercameron/GoWebComponents/html/shorthand" + "github.com/monstercameron/GoWebComponents/ui" ) +type StarterAppProps struct { + Title string + InitialCount int +} + +type CounterPanelProps struct { + Name string + Count int + PreviousCount string + OnIncrement ui.Handler +} + +func CounterPanel(props CounterPanelProps) ui.Node { + return Div( + // Layer 2: Tailwind-shaped typed utilities from css/u — autocompleted and + // compile-checked, no class-string parsing. + u.Class( + u.Flex, u.FlexCol, u.Gap(u.Spacing3), + u.Rounded(u.RadiusXl), u.Border(u.Slate200), u.Bg(u.White), u.Pad(u.Spacing5), + ), + P(u.Class(u.TextSize(u.TextSm), u.Fg(u.Slate600)), Textf("Hello, %s.", props.Name)), + P(u.Class(u.TextSize(u.TextLg), u.FontSemibold, u.Fg(u.Slate900)), Textf("Count: %d", props.Count)), + P(u.Class(u.TextSize(u.TextSm), u.Fg(u.Slate500)), Textf("Previous count: %s", props.PreviousCount)), + Button( + Type("button"), + OnClick(props.OnIncrement), + // Layer 1: typed raw CSS with a hover variant — folds into one hashed + // class. css.Class is an html.PropOption, so it drops into any tag. + css.Class( + css.Rounded(css.Rem(0.75)), + css.PaddingX(css.Rem(1)), css.PaddingY(css.Rem(0.5)), + css.Bg(css.Slate900), css.TextColor(css.White), + css.Hover(css.Bg(css.Slate700)), + ), + "Increment", + ), + ) +} + +func StarterApp(props StarterAppProps) ui.Node { + count := ui.UseState(props.InitialCount) + name := ui.UseState("Go developer") + previousCount := ui.UsePrevious(count.Get()) + + increment := ui.UseEvent(func() { + count.Update(func(previous int) int { return previous + 1 }) + }) + updateName := ui.UseEvent(func(event ui.InputEvent) { + name.Set(event.GetValue()) + }) + + previousLabel := "none yet" + if previousCount.Ok() { + previousLabel = fmt.Sprintf("%d", previousCount.Get()) + } + + return Main( + u.Class(u.Block, u.Bg(u.Slate100), u.PadX(u.Spacing6), u.PadY(u.Spacing12), u.Fg(u.Slate900)), + Div( + u.Class(u.Flex, u.FlexCol, u.Gap(u.Spacing6)), + H1(u.Class(u.TextSize(u.Text4xl), u.FontBold), props.Title), + P(u.Class(u.TextSize(u.TextSm), u.Fg(u.Slate600)), "A small starter that uses dot-imported shorthand tags with typed css/u utilities for state, events, composition, and reactive text."), + Input( + Type("text"), + Value(name.Get()), + OnInput(updateName), + Placeholder("Who is using the app?"), + u.Class(u.WFull, u.Rounded(u.RadiusXl), u.Border(u.Slate300), u.Bg(u.White), u.PadX(u.Spacing4), u.PadY(u.Spacing3), u.TextSize(u.TextSm)), + ), + If(name.Get() == "", P(u.Class(u.TextSize(u.TextSm), u.Fg(u.Amber500)), "Tip: enter a name to personalize the panel.")), + ), + ui.CreateElement(CounterPanel, CounterPanelProps{ + Name: name.Get(), + Count: count.Get(), + PreviousCount: previousLabel, + OnIncrement: increment, + }), + P(u.Class(u.TextSize(u.TextXs), u.Fg(u.Slate500)), Textf("Current count is %d", count.Get())), + ) +} + func main() { - fmt.Println("Rendering TodoList") - - todoList := func(props map[string]interface{}) *fiber.Element { - todos, setTodos := fiber.useState([]string{}) - newTodo, setNewTodo := fiber.useState("") - - handleInputChange := func() js.Func { - return js.FuncOf(func(this js.Value, args []js.Value) interface{} { - setNewTodo(args[0].Get("target").Get("value").String()) - return nil - }) - } - - handleAddTodo := func() js.Func { - return js.FuncOf(func(this js.Value, args []js.Value) interface{} { - if newTodo() != "" { - setTodos(append(todos(), newTodo())) - setNewTodo("") - } - return nil - }) - } - - return fiber.createElement("div", map[string]interface{}{"class": "container mx-auto p-4"}, - fiber.createElement("h1", map[string]interface{}{"class": "text-2xl font-bold mb-4"}, fiber.Text("Todo List")), - fiber.createElement("input", map[string]interface{}{ - "type": "text", "value": newTodo(), "onchange": handleInputChange(), - "class": "border rounded px-2 py-1 mr-2", - }), - fiber.createElement("button", map[string]interface{}{ - "onclick": handleAddTodo(), - "class": "px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600", - }, fiber.Text("Add Todo")), - fiber.createElement("ul", map[string]interface{}{"class": "mt-4"}, - func() []interface{} { - var items []interface{} - for _, todo := range todos() { - items = append(items, fiber.createElement("li", map[string]interface{}{"class": "mb-2"}, fiber.Text(todo))) - } - return items - }()...), - ) - } - - container := js.Global().Get("document").Call("getElementById", "root") - fiber.render(fiber.createElement(todoList, nil), container) + // ui.Run builds the component, mounts it at "#app", and keeps the wasm + // program alive — the one-line equivalent of ui.Render + utils.WaitForever. + ui.Run("#app", StarterApp, StarterAppProps{ + Title: "Starter App", + InitialCount: 0, + }) } ``` -This example demonstrates: -- State management with `useState` -- Event handling -- Dynamic rendering of list items -- Use of Tailwind CSS for styling - -### Building and Running - -1. Save the code in `main.go` -2. Build the WebAssembly binary: - ```bash - GOOS=js GOARCH=wasm go build -o static/bin/main.wasm - ``` -3. Serve the `static` directory with a web server -4. Open `index.html` in your browser to see your Todo List in action! +This version stays small, but it shows the normal flow most React users expect: + +- `UseState` for local UI state +- `UseEvent` for typed event handlers +- Component composition with a child `CounterPanel` +- `UsePrevious` for render-time comparisons +- Dot-imported `html/shorthand` tags and helpers such as `Div`, `Button`, `Textf`, and `If` +- Typed, compile-checked styling: Tailwind-shaped utilities from `css/u` (`u.Flex`, `u.Gap(u.Spacing3)`, `u.Bg(u.White)`, responsive/state variants like `u.Md(...)` / `u.Hover(...)`) layered over raw typed CSS from `css` (`css.Bg(css.Slate900)`, `css.Hover(...)`), which folds into a single hashed class. No Tailwind toolchain or `class` string parsing — `u.Class(...)` / `css.Class(...)` are `html.PropOption`s that drop into any tag, and the wasm sink auto-injects the generated `" in the output. Removing NULs up front means + // the guards run on the final byte stream. + if strings.ContainsRune(parseCSS, 0) { + parseCSS = strings.ReplaceAll(parseCSS, "\x00", "") + } + var b strings.Builder + b.Grow(len(parseCSS) + 8) + for i := 0; i < len(parseCSS); i++ { + c := parseCSS[i] + switch { + case c == '<' && i+1 < len(parseCSS) && isTagStart(parseCSS[i+1]): + // "= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') +} + +// Rules flattens a mix of single Rules and rule slices (the []Rule returned by +// variant helpers) into a flat []Rule, so authoring can freely intermix them: +// +// css.New(css.Rules( +// css.Display.Flex, +// css.Hover(css.Bg(css.Slate800)), // []Rule +// css.Gap(css.Px(8)), +// )...) +func Rules(parts ...any) []Rule { + var out []Rule + for _, p := range parts { + switch t := p.(type) { + case Rule: + out = append(out, t) + case []Rule: + out = append(out, t...) + } + } + return out +} + +// Class is the unified PropOption entry point for Div(...)/shorthand argument +// lists — the typed analog of JSX's className/clsx. It accepts a mixed list of: +// +// - string — a literal class name (migration / third-party / utility strings) +// - Rule — a single typed rule +// - []Rule — the slice returned by variants (Hover, Media, Child, …) +// - Sheet — a pre-folded class from New +// - []Sheet — several pre-folded classes +// +// Typed rules are folded together into one hashed class via New; strings and +// Sheets pass through as class names. Everything is joined into the class +// attribute. Mixing is the whole point: +// +// Div(Class("legacy-util", Display.Flex, Gap(Px(8)), Hover(Bg(Slate900)), someSheet)) +// +// Type-safety note: the compile-checked guarantees live in the rule builders +// (Display.Flex, Gap(Px(8)), …); the argument list is `...any` because the class +// attribute is an inherently stringy boundary (exactly like clsx). Unrecognized +// argument types are ignored. +func Class(parts ...any) html.PropOption { + var names []string + var rules []Rule + collectClassParts(parts, &names, &rules) + if len(rules) > 0 { + if s := New(rules...); s != "" { + names = append(names, string(s)) + } + } + return html.Class(strings.Join(names, " ")) +} + +func collectClassParts(parts []any, names *[]string, rules *[]Rule) { + for _, p := range parts { + switch v := p.(type) { + case string: + if v != "" { + *names = append(*names, v) + } + case Rule: + *rules = append(*rules, v) + case []Rule: + *rules = append(*rules, v...) + case Sheet: + if v != "" { + *names = append(*names, string(v)) + } + case []Sheet: + for _, s := range v { + if s != "" { + *names = append(*names, string(s)) + } + } + case []any: + collectClassParts(v, names, rules) + } + } +} diff --git a/css/css_adversarial_test.go b/css/css_adversarial_test.go new file mode 100644 index 00000000..a2be4b0b --- /dev/null +++ b/css/css_adversarial_test.go @@ -0,0 +1,864 @@ +//go:build !(js && wasm) + +package css_test + +import ( + "math" + "strings" + "sync" + "testing" + + "github.com/monstercameron/GoWebComponents/css" +) + +// ── helpers ────────────────────────────────────────────────────────────────── + +func noStyleBreakout(t *testing.T, output, label string) { + t.Helper() + // When handed a full StyleBlock, strip the legitimate so we scan only the CSS body — otherwise the closing tag is + // a guaranteed false positive. + body := output + if strings.HasPrefix(body, "'); idx >= 0 { + body = body[idx+1:] + } + body = strings.TrimSuffix(body, "") + } + // Any of these appearing unescaped in the CSS body means an attacker controls + // parser context or breaks out of the ", ""`}, + {"comment_break_value", "color", "red/**/}body{color:evil"}, + {"brace_in_value", "content", `"}"}`}, + {"newline_in_value", "color", "red\n}body{color:evil"}, + {"nul_in_value", "color", "red\x00"}, + {"style_close_in_prop", "", "red"}, + {"semicolon_escape_value", "content", `"hello;} body { color: red`}, + } + for _, p := range payloads { + p := p + t.Run(p.name, func(t *testing.T) { + defer func() { + if r := recover(); r != nil { + t.Fatalf("panic: %v", r) + } + }() + css.Reset() + css.New(css.Raw(p.prop, p.val)) + out := css.Harvest() + noStyleBreakout(t, out, p.name) + sb := css.StyleBlock() + noStyleBreakout(t, sb, p.name+"_styleblock") + }) + } +} + +func TestAdversarial_InjectionViaHexColor(t *testing.T) { + // Hex() prepends '#' — but what if the hex string contains injection chars? + payloads := []string{ + ``, + `0af} body{color:red`, + `0af\0`, + "0af\n}*{color:red", + } + for _, p := range payloads { + p := p + t.Run(p, func(t *testing.T) { + defer func() { + if r := recover(); r != nil { + t.Fatalf("panic on Hex injection: %v", r) + } + }() + css.Reset() + css.New(css.Bg(css.Hex(p))) + out := css.Harvest() + noStyleBreakout(t, out, "Hex:"+p) + }) + } +} + +func TestAdversarial_InjectionViaVarColor(t *testing.T) { + // Var() produces var(--name) — injection via the name parameter + payloads := []string{ + "--ok) } body { color: red; } x(", + "", + "ok\x00evil", + } + for _, p := range payloads { + p := p + t.Run(p[:min(len(p), 20)], func(t *testing.T) { + defer func() { + if r := recover(); r != nil { + t.Fatalf("panic: %v", r) + } + }() + css.Reset() + css.New(css.Bg(css.Var(p))) + out := css.Harvest() + noStyleBreakout(t, out, "Var:"+p) + }) + } +} + +func TestAdversarial_InjectionViaClassSel(t *testing.T) { + // ClassSel constructs ".name" — injection via the name + payloads := []string{ + `evil} body{color:red`, + ``}, + {"data-y", "val\nbreaker"}, + } + for _, p := range payloads { + p := p + t.Run(p.name+":"+p.val[:min(len(p.val), 20)], func(t *testing.T) { + defer func() { + if r := recover(); r != nil { + t.Fatalf("panic: %v", r) + } + }() + css.Reset() + css.New(css.Not(css.AttrEq(p.name, p.val), css.Display.Flex)...) + out := css.Harvest() + noStyleBreakout(t, out, "AttrEq") + }) + } +} + +func TestAdversarial_InjectionViaKeyframeOffset(t *testing.T) { + // Keyframe offsets are raw strings — can an attacker inject via them? + offsets := []string{ + `0%} * {color:red} @keyframes foo {0%`, + "", + "100%\n}body{color:red", + } + for _, o := range offsets { + o := o + t.Run(o[:min(len(o), 20)], func(t *testing.T) { + defer func() { + if r := recover(); r != nil { + t.Fatalf("panic: %v", r) + } + }() + css.Reset() + css.New(css.Keyframes("anim", + css.At(o, css.Opacity(0)), + css.At("100%", css.Opacity(1)), + )) + out := css.Harvest() + noStyleBreakout(t, out, "keyframe-offset:"+o) + }) + } +} + +func TestAdversarial_InjectionViaKeyframeName(t *testing.T) { + names := []string{ + `evil} body{color:red} @keyframes x`, + " with no escaping of the content. + // This is the critical question: does in a value break out? + if strings.Contains(sb, ""`)) + css.New(css.Raw("x", "y/**/")) // comment-close attempt + css.New(css.Raw("z", "a\x00b")) // NUL + body := css.Harvest() + for _, bad := range []string{" is its own closing tag. + block := css.StyleBlock() + if n := strings.Count(block, ""); n != 1 { + t.Fatalf("StyleBlock should contain exactly one (closing) , got %d:\n%s", n, block) + } + // Typed constructors are safe-by-construction too. + css.Reset() + css.New(css.Bg(css.Hex(`"`)) + parseOut := css.Harvest() + if strings.Contains(parseOut, "") { + parseT.Fatalf("global CSS must be hardened against breakout, got %q", parseOut) + } +} + +// TestGlobalEmptyInputsAreNoops proves blank selector / empty rules / blank +// inject id are safe no-ops. +func TestGlobalEmptyInputsAreNoops(parseT *testing.T) { + css.Reset() + css.Global("", css.Raw("x", "y")) + css.Global("body") + css.Root() + css.Inject("", "x") + css.Inject("id", "") + if parseOut := css.Harvest(); parseOut != "" { + parseT.Fatalf("expected no emission from empty inputs, got %q", parseOut) + } +} diff --git a/css/global_variant_probe_test.go b/css/global_variant_probe_test.go new file mode 100644 index 00000000..db993fae --- /dev/null +++ b/css/global_variant_probe_test.go @@ -0,0 +1,46 @@ +//go:build !(js && wasm) + +package css_test + +import ( + "strings" + "testing" + + "github.com/monstercameron/GoWebComponents/css" +) + +// TestLayerComposesWithVariant probes Layer + a pseudo-state variant: the layer +// at-rule and the &:hover selector must both appear and nest correctly. +func TestLayerComposesWithVariant(parseT *testing.T) { + css.Reset() + parseSheet := css.Layer("components", css.Hover(css.Raw("color", "red"))...) + parseOut := css.Harvest() + parseExpected := "@layer components{." + string(parseSheet) + ":hover{color:red" + if !strings.Contains(parseOut, parseExpected) { + parseT.Fatalf("Layer+Hover: expected %q in %q", parseExpected, parseOut) + } +} + +// TestGlobalComposesWithMedia probes a global selector wrapped in @media. +func TestGlobalComposesWithMedia(parseT *testing.T) { + css.Reset() + css.Global("body", css.Media(css.MinW(768), css.Raw("margin", "0"))...) + parseOut := css.Harvest() + if !strings.Contains(parseOut, "@media") || !strings.Contains(parseOut, "body{margin:0") { + parseT.Fatalf("Global+Media: expected media-wrapped body rule, got %q", parseOut) + } +} + +// TestLayerGlobalWithAncestorVariant probes LayerGlobal carrying a Within +// ancestor selector — the override-layer + theme-attr combination. +func TestLayerGlobalWithAncestorVariant(parseT *testing.T) { + css.Reset() + css.LayerGlobal("overrides", ".card", css.DataTheme("light", css.Raw("background", "white"))...) + parseOut := css.Harvest() + if !strings.Contains(parseOut, "@layer overrides{") { + parseT.Fatalf("expected @layer overrides wrapper, got %q", parseOut) + } + if !strings.Contains(parseOut, `[data-theme="light"]`) || !strings.Contains(parseOut, "background:white") { + parseT.Fatalf("expected data-theme-scoped .card override, got %q", parseOut) + } +} diff --git a/css/inject_fuzz_test.go b/css/inject_fuzz_test.go new file mode 100644 index 00000000..238441ee --- /dev/null +++ b/css/inject_fuzz_test.go @@ -0,0 +1,38 @@ +//go:build !(js && wasm) + +package css_test + +import ( + "strings" + "testing" + + "github.com/monstercameron/GoWebComponents/css" +) + +// FuzzInjectHardening fuzzes the arbitrary-CSS-string injection surface to prove +// the or (which would terminate the style raw- +// text element) or a */ (which would close a CSS comment). +func FuzzInjectHardening(parseF *testing.F) { + for _, parseSeed := range []string{ + "", "a{}", "", "", "", "a{}*/b{}", + "\x00", "", " + +# Benchmark Drift Note + +This note is generated from `docs/benchmarks/latest.json`. CI byte-compares it against the committed file so benchmark-report updates also refresh the published drift status. + +## Current Report + +- Generated at: `2026-03-25T15:30:55Z` +- Toolchain: `go1.26.0 windows/amd64` +- Report path: `./docs/benchmarks/latest.json` +- Packages / benchmarks: `31 / 249` +- Selected lanes: `native, wasm` +- Failed packages: `0` + +## Normalized Score + +- Method: `100 * geometric_mean(reference_ns / measured_ns)` +- Reference: `./docs/benchmarks/reference.json` generated at `2026-03-25T15:17:41Z` +- Matched benchmarks: `249` +- Overall score: `100.6` + +## Drift Status + +- Status: `drift beyond tolerance detected` +- Baseline generated at: `2026-03-25T15:17:41Z` +- Tolerance: `2.0%` +- Matched metrics: `747` +- Improved / regressed / unchanged: `109 / 114 / 524` + +### Top Regressions + +| Lane | Package | Benchmark | Metric | Baseline | Current | Delta | Delta % | +| --- | --- | --- | --- | ---: | ---: | ---: | ---: | +| native | `./internal/runtime` | `BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20` | `ns/op` | 11512 | 25676 | 14164 | 123.0% | +| native | `./internal/runtime` | `BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20` | `ns/op` | 26564 | 43051 | 16487 | 62.1% | +| native | `./internal/runtime` | `BenchmarkGoUseEffectSameDeps-20` | `ns/op` | 42.1 | 67.35 | 25.25 | 60.0% | +| native | `./prerender` | `BenchmarkBuildTargetJSONBootstrap-20` | `ns/op` | 395.8 | 619.4 | 223.6 | 56.5% | +| wasm | `./internal/runtime` | `BenchmarkGoUseAtomGlobalInit` | `ns/op` | 3454 | 5243 | 1789 | 51.8% | + +### Top Improvements + +| Lane | Package | Benchmark | Metric | Baseline | Current | Delta | Delta % | +| --- | --- | --- | --- | ---: | ---: | ---: | ---: | +| wasm | `./testkit/hooks` | `BenchmarkRenderHookStateRerenderMicroWasm` | `ns/op` | 109077 | 57362 | -51715 | -47.4% | +| native | `./diagnostics` | `BenchmarkWriteHTTPError-20` | `ns/op` | 31498 | 17399 | -14099 | -44.8% | +| wasm | `./internal/runtime` | `BenchmarkPerformUnitOfWorkFunctionComponentLeaf` | `ns/op` | 7045 | 4152 | -2893 | -41.1% | +| wasm | `./testkit/router` | `BenchmarkCloneStringMapMicroWasm` | `ns/op` | 281.9 | 167.1 | -114.8 | -40.7% | +| wasm | `./internal/runtime` | `BenchmarkHydrateTagMismatchFallback` | `ns/op` | 76790 | 45623 | -31167 | -40.6% | + diff --git a/docs/benchmarks/MICROBENCH_REPORT_arm64.md b/docs/benchmarks/MICROBENCH_REPORT_arm64.md new file mode 100644 index 00000000..c685c1c0 --- /dev/null +++ b/docs/benchmarks/MICROBENCH_REPORT_arm64.md @@ -0,0 +1,202 @@ +# GoWebComponents — Whole-Program Microbenchmark Report + +- **Machine / toolchain:** `go1.26.3` `windows/arm64` (Snapdragon X2, 18 logical CPUs) +- **Generated:** 2026-06-13 +- **Harness:** `gwc bench --lane all` (`go test -run ^$ -bench . -benchmem`), native + js/wasm lanes +- **Coverage:** 500 benchmarks across 34 package×lane targets — **391 native**, **109 wasm** +- **Raw data:** `docs/benchmarks/run-arm64.json` · profiles in `bin/prof/` · latency samples in `bin/prof/latency.txt` +- **Note:** the committed `docs/benchmarks/latest.json` (amd64, go1.26.0) was **not** overwritten; this run went to `run-arm64.json`. + +## 1. Throughput — core hot paths (native) + +| Path | Benchmark | ns/op | B/op | allocs/op | +| --- | --- | ---: | ---: | ---: | +| Diff, stable list (16) | `ReconcileChildrenStableList16` | 3,303 | **0** | **0** | +| Diff, with fragments | `ReconcileChildrenWithFragments16` | 3,553 | 24 | 1 | +| Diff, keyed | `ReconcileChildrenKeyedStableList16` | 4,028 | 48 | 2 | +| Component unit-of-work | `PerformUnitOfWorkFunctionComponentLeaf` | 7,762 | 776 | 6 | +| Targeted reactive text update | `FineGrainedKeyedDashboardReactiveTextUpdate16` | 3,112 | 184 | 8 | +| Full 16-component re-render | `FineGrainedKeyedDashboardComponentUpdate16` | 46,080 | 10,140 | 150 | +| SSR render (public surface) | `RenderToStringPublicSSRSurface` | 2,830 | — | — | +| SSR render, 100 rows | `SSRRenderToString100Rows` | 304,700 | — | — | +| Bootstrap marshal (binary) | `MarshalSSRBootstrapBinary` | 1,810 | — | — | +| No-op patch stream | `BuildPatchStreamIdentity` | **~10** | — | — | + +**Reads:** +- The steady-state child diff is **allocation-free** (0 B/op, 0 allocs/op) — the reconciler reuses fiber/prop structures on stable lists. +- **Fine-grained reactivity earns its keep:** a targeted reactive-text update (3.1µs / 8 allocs) is **~15× cheaper** than re-rendering the 16-component subtree (46µs / 150 allocs). +- The identity/no-op patch path short-circuits to ~10ns — unchanged regions cost essentially nothing. + +## 2. `CurrentVsLegacy` A/B suite — current engine vs deprecated paths + +The codebase carries paired benchmarks proving the current engine beats the legacy implementations it replaced. These dominate the "slowest" list precisely because the *legacy* arm is the baseline being beaten: + +| Benchmark | current (native) | legacy (native) | speedup | +| --- | ---: | ---: | ---: | +| `ApplyCommittedChildOrder` | 162.8µs | 8.16ms | **~50×** | +| `BuildCanonicalRenderIR` | 985µs | 1.11ms | ~1.13× + fewer allocs | +| `CommitRegionPatchTransaction/append-256` | partial-snapshot | 855µs / **1.63 MB**/op (reclone) | reclone is the alloc hog | + +The legacy `reclone` snapshot path allocates **1.63 MB/op**; the current partial-snapshot path is the optimization. Keep the legacy arms as regression guards only. + +## 3. CPU & allocation hotspots (pprof) + +### Reconcile engine (`internal/runtime`, pure diff/commit) +Time concentrates in fiber cloning: +- `(*Runtime).buildUpdatedFiber` — 17.5% cum +- `(*Runtime).cloneChildFibers` — 3.5% cum +- `(*Runtime).commitWork` — 2.9% cum + +→ The main lever for further reconcile speedups is reducing fiber-clone work on update. + +### ⚠️ Inspector instrumentation dominates the "representative scenarios" +`BenchmarkProfilingRepresentativeScenarios` (large-list / nested-routes / async-dashboard / portal-overlays, ~7µs each) spends **>50% CPU in `(*Runtime).Inspect`** and **90.6% of all allocations (45.5 GB cumulative) in `collectFlamegraphFrames`**, plus `inspectFiberTreeWithPath` / `collectHotBranches`. This benchmark measures the **devtools inspector/flamegraph machinery**, not pure rendering. Worth confirming the inspector is meant to be live on this path — if it leaks into production renders it's a massive allocation source. + +### Sanitize is parser-bound, not GWC-bound +`SanitizeLargeDocument` (1.39ms, 679 KB, 7050 allocs): **66% of allocations are inside `golang.org/x/net/html.ParseFragmentWithOptions`** (`addElement` 32%, `addText` 26%, `strings.Builder` 26%). GWC's only hot function is `stripControlChars` (9% CPU). Throughput here is bounded by the upstream HTML parser; GWC-side optimization headroom is small. + +## 4. Latency distribution (`-count=10`, native) + +| Benchmark | min | median | max | CV% | +| --- | ---: | ---: | ---: | ---: | +| `ReconcileChildrenStableList16` | 3.29µs | 3.35µs | 3.47µs | 1.6 | +| `FineGrainedKeyedDashboardReactiveTextUpdate16` | 3.00µs | 3.11µs | 3.56µs | 5.0 | +| `FineGrainedKeyedDashboardComponentUpdate16` | 39.1µs | 41.0µs | 43.9µs | 3.3 | +| `RenderToStringPublicSSRSurface` | 3.48µs | 3.82µs | 4.22µs | 6.2 | +| `MarshalSSRBootstrapBinary` | 1.73µs | 1.81µs | 1.86µs | 2.0 | +| `BuildPatchStreamIdentity/*` | 10ns | 10ns | 11ns | ~3.5 | +| `SanitizeLargeDocument` | 1.10ms | 1.29ms | **2.06ms** | **20.0** | + +Core engine paths are very stable (CV ≤ 6%). The outlier is **sanitize (CV 20%, p-max 2.06ms vs median 1.29ms)** — its tail is GC-driven, a direct consequence of the 679 KB/op parser allocation. + +## 5. Native vs WASM + +Go/wasm runs the same code **~4.5–6.5× slower** than native: + +| Benchmark | native | wasm | ratio | +| --- | ---: | ---: | ---: | +| `ReconcileChildrenKeyedStableList16` | 4.03µs | 25.82µs | 6.4× | +| `SSRRenderToString100Rows` | 304.7µs | 1.38ms | 4.5× | +| `ApplyCommittedChildOrder/current` | 162.8µs | 816µs | 5.0× | + +Allocation counts are identical across lanes (same code); only wall-time scales. Budget client-side (wasm) render work at ~5× the native number. + +## 6. Caveats — 3 wasm-lane targets failed (pre-existing, not benchmark regressions) + +- **`state` (wasm):** build failure — `ExampleUseAtom` redeclared in `example_test.go` and `useatom_example_test.go`. Genuine test-file bug; blocks the package's wasm benchmarks. +- **`interop` (wasm):** `TestGetCookieNativeReturnsUnavailable` panics under the node wasm host (`syscall/js: Value.Get on undefined` in `readRawCookies`). +- **`internal/platform/jsdom` (wasm):** test failure under the node host. + +None are caused by this run, and none affect the 500 measured benchmarks. The `state` redeclaration is a quick, worthwhile fix. + +## 7. SLA / budget analysis + +There is **no absolute latency SLA defined in-repo** — the only codified budget is the harness's **2% regression tolerance** plus a normalized score (100 = parity with the committed `reference.json`). The runtime also tracks `RouteStartupBudget` telemetry (hydration / startup-commit / first-interaction durations) but with no threshold constants. So this section judges against two lenses: the **60fps frame budget (16.67ms)** — the natural SLA for a render framework — and the framework's own **relative score**. + +### Frame-budget SLA (16.67ms = one 60fps frame) + +**No production path violates the frame budget, in either lane.** The only path over 16.67ms is a deliberately-retained *legacy* A/B baseline. + +| Lane | Over 16.67ms (frame) | 1–16.67ms (sub-frame, watch) | +| --- | --- | --- | +| native | 0 (legacy A/B arm 8.16ms only) | sanitize 1.24ms; legacy IR build 1.11ms | +| **wasm** (browser runtime) | 0 production (`ApplyCommittedChildOrder/legacy` 36.35ms is the A/B baseline) | see below | + +**WASM sub-frame watch list** (wasm is the real client runtime, so these matter most): + +| ns→ms | Path | Note | +| ---: | --- | --- | +| **13.08ms** | `GoUseFetchRefetchUnavailable` | 🔴 anomalous — ~¾ of a frame for a fetch-unavailable path; likely an error/retry branch. Investigate. | +| 3.81ms | `HydrateMediumTreeFirstUpdate` | 🟡 one-time hydration, ~7000 allocs | +| 3.68ms | `HydrateMediumTreeReuse` | 🟡 hydration reuse path | +| 2.24ms | `CurrentNestedLayoutRoute` | nested route resolution | +| 1.63ms | `TransitionListRefresh250` | 250-item list refresh | +| 1.38ms | `SSRRenderToString100Rows` | SSR (normally native, not wasm) | +| 1.02ms | `ProfilingRepresentativeScenarios/portal-overlays` | inspector-laden (see §3) | + +### Relative SLA (normalized score vs `reference.json`) + +Overall **67/100** — but the reference is amd64 / go1.26.0 and this run is **arm64 Snapdragon X2**, so the absolute level is mostly an architecture artifact. The diagnostic value is the **bucket spread**: + +| Bucket | Score | Benches | +| --- | ---: | ---: | +| Compute | 82.8 | 6 | +| Memory | 80.3 | 2 | +| End-to-End | 79.7 | 7 | +| Sync/Concurrency | 73.0 | 11 | +| **Alloc/Runtime** | **35.1** | **71** | + +Compute/Memory/E2E/Sync cluster at ~73–83 (consistent with this core being ~20–25% slower than the reference box). **Alloc/Runtime is the outlier at 35** — ~2.3× worse than every other bucket. That is the real "below SLA" signal: **allocation-heavy runtime paths underperform disproportionately on this hardware.** The CPU profile confirms it — `runtime.mallocgc` is **26.7%** of CPU, with GC scan/`memclrNoHeapPointers`/`sysUnusedOS` dominating the rest. **GC/allocation, not compute, is the systemic bottleneck**, and on a fanless ARM laptop that also costs battery/thermal. + +**Allocation hogs feeding that bucket:** inspector `collectFlamegraphFrames` (45.5 GB cumulative — likely should not be live on render), legacy `reclone` snapshot (1.63 MB/op), hydration (~7000 allocs), sanitize (679 KB, parser-bound). + +## 8. Optimizations applied + +### ✅ Inspector flamegraph collection — `collectFlamegraphFrames` (`internal/runtime/inspect.go`) + +The single largest allocation site in the whole sweep. Root causes: +1. `make([]FlamegraphFrameSnapshot, 0, 256)` preallocated a ~30 KB backing array on **every** call, while real snapshots emit only a handful of frames. +2. `append(append([]string(nil), path...), name)` copied the entire ancestor path **at every node** (O(N·D)). +3. Frames were built for the whole tree, then truncated to 256. + +Fix: lazy-grown result slice (cap 16, grows as needed), a single reused push/pop path stack, and early-exit once the limit is hit. Behavior-preserving (DFS order, `Path` format, frame[0] timings all unchanged; `inspect`/`plugininterposer` tests pass). + +| `BenchmarkProfilingRepresentativeScenarios` | Before | After | Δ | +| --- | ---: | ---: | ---: | +| B/op | 36,150 | **5,348** | **−85%** | +| allocs/op | 33 | 30 | −9% | +| ns/op | ~6,900 | **~3,600** | **~1.9× faster** | + +Cumulative allocation of `collectFlamegraphFrames` over a 2s run fell from **45.5 GB → 1.4 GB**; total `Inspect()` allocation 50 GB → 3.7 GB. This speeds up every devtools/agent snapshot query (the path is *not* on the production render loop, confirmed via `plugininterposer.go`). + +### ✅ SSR attribute serialization — `writeSSRProps` / `serializeProps` / `serializeStyleMap` (`internal/runtime/ssr.go`) + +Each function allocated a `[]string` key buffer per element (runtime-sized → heap) and passed it to `sort.Strings`, which boxes into `sort.Interface` and forces the backing array to escape. Fix: a stack-allocated 16-element small buffer + `slices.Sort` (generic, no boxing) → allocation-free key sorting for the common case (≤16 attributes), identical lexical output. + +| `BenchmarkSSRRenderToString100Rows` | Before | After | Δ | +| --- | ---: | ---: | ---: | +| allocs/op | 2,406 | **2,306** | −100 (one heap slice per row) | +| B/op | 219,509 | 214,707 | −4,800 | +| ns/op | ~247k | ~249k | neutral (verified, count=12) | + +Escape analysis confirms the buffer stays on the stack. Benefits all SSR/serialization output. + +### ✅ Telemetry redaction array path — `redactValue` (`internal/telemetryredaction/redaction.go`) + +Per array element, the redactor built an indexed field path with `fmt.Sprintf("%s[%d]", …)` — interface boxing + format parsing on a path that runs on **every redacted telemetry log/trace framework-wide** (via `logging.RedactTelemetryValue`). Replaced with `parsePath + "[" + strconv.Itoa(i) + "]"`. Added the package's first benchmark (`BenchmarkRedactValueNestedArrays`) for regression coverage. + +| `BenchmarkRedactValueNestedArrays` | Before | After | Δ | +| --- | ---: | ---: | ---: | +| ns/op | 4,175 | **2,945** | **−29%** | +| allocs/op | 65 | **48** | **−26%** | +| B/op | 2,906 | 2,632 | −9% | + +### 🎯 Central finding: `cloneElementProps` is the framework-wide allocation bottleneck + +Four separate benchmarks — component update, SSR, list-transition refresh, hydration — are all dominated (46–56% of allocations) by `cloneElementProps` + `buildElementWithHostProps`. `CreateElement(tag, props, …)` defensively clones the props map because arbitrary callers may retain/mutate it. The common idiom `CreateElement("li", map[string]any{…}, …)` passes a **fresh, never-reused literal**, making the clone redundant — but the API can't know that at runtime. An opt-out (`CreateElementOwned`) already exists. + +This is the single highest-leverage optimization for the whole framework, but it requires an **architectural decision**, not a micro-edit: +- migrate hot internal/sugar call sites that build fresh maps to `CreateElementOwned`, or +- move to copy-on-write / builder-based props, or a slice-backed small-map for the common ≤4-key case (maps carry high fixed overhead). + +Recommend prototyping behind the existing `Owned` fast path and A/B-ing before committing. + +### Investigated and intentionally **not** changed (risk/benchmark-artifact) + +- **`GoUseFetchRefetchUnavailable` (13 ms wasm)** — the cost is the *benchmark's own* `time.Sleep(1ms)` poll loop (2 s deadline), not framework code. Nothing to optimize; the benchmark measures sleep. +- **`cloneElementProps` (53% of component-update allocs)** — a deliberate safety contract of the public `CreateElement` (callers may retain the props map). An opt-out already exists (`CreateElementOwned`). Removing the clone risks caller-mutation bugs across every app; a real fix is architectural (small-map/slice-backed props), needing design buy-in. +- **Hydration diagnostics (~16% of hydrate allocs)** — driven by the benchmark's mock producing text mismatches; ~32% of the rest is the **test DOM adapter**, not production code. Optimizing would chase a benchmark artifact. +- **`BuildSnapshotTransportPayloadWithFallback/binary-fallback` (897k ns, 369 KB)** — an edge **error path**: it builds the binary buffer, then fails on a pathological 70,000-char region ID (binary uses a uint16 length prefix, max 65,535) and falls back to structured-clone JSON. The common `binary-success` path is already 524 ns / 1 alloc. A complete pre-check would duplicate the entire encode walk; a partial one would only fast-path this benchmark's pathological input. +- **`TransitionListRefresh250` / `CompareSnapshots` export** — the former is dominated by `cloneElementProps` (see central finding); the latter by `ExportSnapshotJSON` building full redacted-JSON trees for both snapshots (inherent to its compare-by-export design). The redaction sub-cost was optimized above. + +## How to reproduce + +``` +go run ./tools/gwc bench --lane all --out docs/benchmarks/run-arm64.json +# focused profiling: +go test ./internal/runtime -run ^$ -bench BenchmarkProfilingRepresentativeScenarios \ + -benchmem -cpuprofile cpu.prof -memprofile mem.prof +go tool pprof -top -sample_index=alloc_space mem.prof +# latency spread: +go test ./sanitize -run ^$ -bench SanitizeLargeDocument -benchmem -count 10 +``` diff --git a/docs/benchmarks/benchmarks.go b/docs/benchmarks/benchmarks.go new file mode 100644 index 00000000..01708ede --- /dev/null +++ b/docs/benchmarks/benchmarks.go @@ -0,0 +1,204 @@ +package benchmarks + +import ( + "encoding/json" + "fmt" + "math" + "os" + "sort" + "strconv" + "strings" +) + +const driftNoteTopEntryCount = 5 + +type BenchmarkReport struct { + OK bool `json:"ok"` + Root string `json:"root"` + GeneratedAt string `json:"generatedAt"` + GoVersion string `json:"goVersion"` + GOOS string `json:"goos"` + GOARCH string `json:"goarch"` + SelectedLanes []string `json:"selectedLanes"` + Bench string `json:"bench"` + Count int `json:"count"` + PackageParallelism int `json:"packageParallelism"` + ReportPath string `json:"reportPath"` + PackageCount int `json:"packageCount"` + BenchmarkCount int `json:"benchmarkCount"` + FailedPackages int `json:"failedPackages"` + Scores *BenchmarkScoreSummary `json:"scores,omitempty"` + Comparison *BenchmarkComparisonSummary `json:"comparison,omitempty"` +} + +type BenchmarkScoreSummary struct { + Method string `json:"method"` + ReferencePath string `json:"referencePath"` + ReferenceGeneratedAt string `json:"referenceGeneratedAt"` + ReferenceMachine string `json:"referenceMachine"` + MatchedBenchmarks int `json:"matchedBenchmarks"` + OverallScore float64 `json:"overallScore"` + Buckets []BenchmarkBucketScore `json:"buckets"` +} + +type BenchmarkBucketScore struct { + ID string `json:"id"` + Label string `json:"label"` + MatchedBenchmarks int `json:"matchedBenchmarks"` + Score float64 `json:"score"` +} + +type BenchmarkComparisonSummary struct { + BaselineGeneratedAt string `json:"baselineGeneratedAt,omitempty"` + TolerancePct float64 `json:"tolerancePct"` + MatchedMetrics int `json:"matchedMetrics"` + Improved int `json:"improved"` + Regressed int `json:"regressed"` + Unchanged int `json:"unchanged"` + Entries []BenchmarkMetricComparison `json:"entries,omitempty"` +} + +type BenchmarkMetricComparison struct { + Lane string `json:"lane"` + Package string `json:"package"` + Benchmark string `json:"benchmark"` + Metric string `json:"metric"` + Baseline float64 `json:"baseline"` + Current float64 `json:"current"` + Delta float64 `json:"delta"` + DeltaPct float64 `json:"deltaPct"` + Direction string `json:"direction"` +} + +func LoadReport(parsePath string) (BenchmarkReport, error) { + parseBytes, parseErr := os.ReadFile(parsePath) + if parseErr != nil { + return BenchmarkReport{}, parseErr + } + var parseReport BenchmarkReport + if parseErr2 := json.Unmarshal(parseBytes, &parseReport); parseErr2 != nil { + return BenchmarkReport{}, parseErr2 + } + return parseReport, nil +} + +func RenderDriftNote(parseReport BenchmarkReport) string { + var parseBuilder strings.Builder + parseBuilder.WriteString("\n\n") + parseBuilder.WriteString("# Benchmark Drift Note\n\n") + parseBuilder.WriteString("This note is generated from `docs/benchmarks/latest.json`. CI byte-compares it against the committed file so benchmark-report updates also refresh the published drift status.\n\n") + + parseBuilder.WriteString("## Current Report\n\n") + fmt.Fprintf(&parseBuilder, "- Generated at: `%s`\n", fallback(parseReport.GeneratedAt, "unknown")) + fmt.Fprintf(&parseBuilder, "- Toolchain: `%s %s/%s`\n", fallback(parseReport.GoVersion, "unknown"), fallback(parseReport.GOOS, "unknown"), fallback(parseReport.GOARCH, "unknown")) + fmt.Fprintf(&parseBuilder, "- Report path: `%s`\n", fallback(parseReport.ReportPath, "docs/benchmarks/latest.json")) + fmt.Fprintf(&parseBuilder, "- Packages / benchmarks: `%d / %d`\n", parseReport.PackageCount, parseReport.BenchmarkCount) + fmt.Fprintf(&parseBuilder, "- Selected lanes: `%s`\n", strings.Join(parseReport.SelectedLanes, ", ")) + fmt.Fprintf(&parseBuilder, "- Failed packages: `%d`\n\n", parseReport.FailedPackages) + + if parseReport.Scores != nil { + parseScores := parseReport.Scores + parseBuilder.WriteString("## Normalized Score\n\n") + fmt.Fprintf(&parseBuilder, "- Method: `%s`\n", fallback(parseScores.Method, "unknown")) + fmt.Fprintf(&parseBuilder, "- Reference: `%s` generated at `%s`\n", fallback(parseScores.ReferencePath, "unknown"), fallback(parseScores.ReferenceGeneratedAt, "unknown")) + fmt.Fprintf(&parseBuilder, "- Matched benchmarks: `%d`\n", parseScores.MatchedBenchmarks) + fmt.Fprintf(&parseBuilder, "- Overall score: `%s`\n\n", formatFloat(parseScores.OverallScore, 1)) + } + + parseBuilder.WriteString("## Drift Status\n\n") + if parseReport.Comparison == nil { + parseBuilder.WriteString("No comparison summary is present in the current benchmark report.\n") + return parseBuilder.String() + } + + parseComparison := parseReport.Comparison + parseStatus := "no drift beyond tolerance" + if parseComparison.Regressed > 0 { + parseStatus = "drift beyond tolerance detected" + } else if parseComparison.Improved > 0 { + parseStatus = "improvements beyond tolerance detected" + } + fmt.Fprintf(&parseBuilder, "- Status: `%s`\n", parseStatus) + fmt.Fprintf(&parseBuilder, "- Baseline generated at: `%s`\n", fallback(parseComparison.BaselineGeneratedAt, "unknown")) + fmt.Fprintf(&parseBuilder, "- Tolerance: `%s%%`\n", formatFloat(parseComparison.TolerancePct, 1)) + fmt.Fprintf(&parseBuilder, "- Matched metrics: `%d`\n", parseComparison.MatchedMetrics) + fmt.Fprintf(&parseBuilder, "- Improved / regressed / unchanged: `%d / %d / %d`\n\n", parseComparison.Improved, parseComparison.Regressed, parseComparison.Unchanged) + + writeEntryTable(&parseBuilder, "Top Regressions", topEntries(parseComparison.Entries, "regressed", driftNoteTopEntryCount)) + writeEntryTable(&parseBuilder, "Top Improvements", topEntries(parseComparison.Entries, "improved", driftNoteTopEntryCount)) + return parseBuilder.String() +} + +func writeEntryTable(parseBuilder *strings.Builder, parseTitle string, parseEntries []BenchmarkMetricComparison) { + if len(parseEntries) == 0 { + return + } + fmt.Fprintf(parseBuilder, "### %s\n\n", parseTitle) + parseBuilder.WriteString("| Lane | Package | Benchmark | Metric | Baseline | Current | Delta | Delta % |\n") + parseBuilder.WriteString("| --- | --- | --- | --- | ---: | ---: | ---: | ---: |\n") + for _, parseEntry := range parseEntries { + fmt.Fprintf(parseBuilder, "| %s | `%s` | `%s` | `%s` | %s | %s | %s | %s%% |\n", + escapeMarkdownTable(parseEntry.Lane), + escapeMarkdownTable(parseEntry.Package), + escapeMarkdownTable(parseEntry.Benchmark), + escapeMarkdownTable(parseEntry.Metric), + formatMetric(parseEntry.Baseline), + formatMetric(parseEntry.Current), + formatMetric(parseEntry.Delta), + formatFloat(parseEntry.DeltaPct, 1)) + } + parseBuilder.WriteString("\n") +} + +func topEntries(parseEntries []BenchmarkMetricComparison, parseDirection string, parseLimit int) []BenchmarkMetricComparison { + parseFiltered := make([]BenchmarkMetricComparison, 0, parseLimit) + for _, parseEntry := range parseEntries { + if parseEntry.Direction == parseDirection { + parseFiltered = append(parseFiltered, parseEntry) + } + } + sort.Slice(parseFiltered, func(parseI, parseJ int) bool { + parseLeft := math.Abs(parseFiltered[parseI].DeltaPct) + parseRight := math.Abs(parseFiltered[parseJ].DeltaPct) + if parseLeft == parseRight { + if parseFiltered[parseI].Package == parseFiltered[parseJ].Package { + if parseFiltered[parseI].Benchmark == parseFiltered[parseJ].Benchmark { + return parseFiltered[parseI].Metric < parseFiltered[parseJ].Metric + } + return parseFiltered[parseI].Benchmark < parseFiltered[parseJ].Benchmark + } + return parseFiltered[parseI].Package < parseFiltered[parseJ].Package + } + return parseLeft > parseRight + }) + if len(parseFiltered) > parseLimit { + return parseFiltered[:parseLimit] + } + return parseFiltered +} + +func formatMetric(parseValue float64) string { + parseFormatted := strconv.FormatFloat(parseValue, 'f', 3, 64) + parseFormatted = strings.TrimRight(parseFormatted, "0") + parseFormatted = strings.TrimRight(parseFormatted, ".") + if parseFormatted == "-0" { + return "0" + } + return parseFormatted +} + +func formatFloat(parseValue float64, parsePrecision int) string { + return strconv.FormatFloat(parseValue, 'f', parsePrecision, 64) +} + +func fallback(parseValue string, parseFallback string) string { + if strings.TrimSpace(parseValue) == "" { + return parseFallback + } + return parseValue +} + +func escapeMarkdownTable(parseValue string) string { + parseValue = strings.ReplaceAll(parseValue, "\\", "\\\\") + return strings.ReplaceAll(parseValue, "|", "\\|") +} diff --git a/docs/benchmarks/benchmarks_test.go b/docs/benchmarks/benchmarks_test.go new file mode 100644 index 00000000..767766f1 --- /dev/null +++ b/docs/benchmarks/benchmarks_test.go @@ -0,0 +1,103 @@ +package benchmarks + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +const latestReportRel = "latest.json" +const driftNoteRel = "DRIFT_NOTE.md" + +func TestLoadReportReadsCommittedBenchmarkReport(parseT *testing.T) { + parseReport, parseErr := LoadReport(filepath.FromSlash(latestReportRel)) + if parseErr != nil { + parseT.Fatalf("load latest report: %v", parseErr) + } + if !parseReport.OK { + parseT.Fatal("latest benchmark report is not marked ok") + } + if parseReport.GeneratedAt == "" { + parseT.Fatal("latest benchmark report has no generatedAt") + } + if parseReport.Comparison == nil { + parseT.Fatal("latest benchmark report has no comparison summary") + } + if parseReport.Comparison.TolerancePct <= 0 { + parseT.Fatalf("expected positive comparison tolerance, got %v", parseReport.Comparison.TolerancePct) + } +} + +func TestRenderDriftNoteSummarizesRegressionsAndImprovements(parseT *testing.T) { + parseNote := RenderDriftNote(BenchmarkReport{ + OK: true, + GeneratedAt: "2026-06-12T00:00:00Z", + GoVersion: "go1.26.0", + GOOS: "windows", + GOARCH: "amd64", + SelectedLanes: []string{"native"}, + ReportPath: "./docs/benchmarks/latest.json", + PackageCount: 1, + BenchmarkCount: 2, + Scores: &BenchmarkScoreSummary{ + Method: "score method", + ReferencePath: "./docs/benchmarks/reference.json", + ReferenceGeneratedAt: "2026-06-11T00:00:00Z", + MatchedBenchmarks: 2, + OverallScore: 101.25, + }, + Comparison: &BenchmarkComparisonSummary{ + BaselineGeneratedAt: "2026-06-11T00:00:00Z", + TolerancePct: 2, + MatchedMetrics: 2, + Improved: 1, + Regressed: 1, + Entries: []BenchmarkMetricComparison{ + {Lane: "native", Package: "./pkg", Benchmark: "BenchmarkSlow", Metric: "ns/op", Baseline: 10, Current: 12.5, Delta: 2.5, DeltaPct: 25, Direction: "regressed"}, + {Lane: "native", Package: "./pkg", Benchmark: "BenchmarkFast", Metric: "ns/op", Baseline: 10, Current: 8, Delta: -2, DeltaPct: -20, Direction: "improved"}, + }, + }, + }) + + for _, parseWant := range []string{ + "drift beyond tolerance detected", + "Top Regressions", + "BenchmarkSlow", + "Top Improvements", + "BenchmarkFast", + "101.2", + } { + if !strings.Contains(parseNote, parseWant) { + parseT.Fatalf("expected drift note to contain %q:\n%s", parseWant, parseNote) + } + } +} + +// TestBenchmarkDriftNoteIsGenerated is the CI drift guard: the committed note +// must byte-match the current benchmark report. Run with BENCHMARKS_WRITE=1 to +// regenerate after updating docs/benchmarks/latest.json. +func TestBenchmarkDriftNoteIsGenerated(parseT *testing.T) { + parseReport, parseErr := LoadReport(filepath.FromSlash(latestReportRel)) + if parseErr != nil { + parseT.Fatalf("load latest benchmark report: %v", parseErr) + } + parseExpected := RenderDriftNote(parseReport) + parsePath := filepath.FromSlash(driftNoteRel) + + if os.Getenv("BENCHMARKS_WRITE") != "" { + if parseWriteErr := os.WriteFile(parsePath, []byte(parseExpected), 0o644); parseWriteErr != nil { + parseT.Fatalf("write benchmark drift note: %v", parseWriteErr) + } + parseT.Logf("regenerated %s", parsePath) + return + } + + parseActual, parseReadErr := os.ReadFile(parsePath) + if parseReadErr != nil { + parseT.Fatalf("read benchmark drift note (regenerate with BENCHMARKS_WRITE=1 go test ./docs/benchmarks/): %v", parseReadErr) + } + if strings.ReplaceAll(string(parseActual), "\r\n", "\n") != parseExpected { + parseT.Fatalf("benchmark drift note is stale; regenerate with BENCHMARKS_WRITE=1 go test ./docs/benchmarks/") + } +} diff --git a/docs/benchmarks/build-times.json b/docs/benchmarks/build-times.json new file mode 100644 index 00000000..2eaa8160 --- /dev/null +++ b/docs/benchmarks/build-times.json @@ -0,0 +1,12 @@ +{ + "ok": true, + "root": "", + "pattern": "./examples/public/counter", + "target": "wasm", + "cycles": 2, + "coldDurationMs": 9025, + "warmDurationMs": 396, + "lastDurationMs": 396, + "speedupRatio": 0.04396208215721697, + "maxWarmRatio": 0.6 +} diff --git a/docs/benchmarks/latest.json b/docs/benchmarks/latest.json new file mode 100644 index 00000000..406cb009 --- /dev/null +++ b/docs/benchmarks/latest.json @@ -0,0 +1,13602 @@ +{ + "ok": true, + "root": ".", + "generatedAt": "2026-03-25T15:30:55Z", + "goVersion": "go1.26.0", + "goos": "windows", + "goarch": "amd64", + "selectedLanes": [ + "native", + "wasm" + ], + "bench": ".", + "count": 1, + "packageParallelism": 1, + "reportPath": "./docs/benchmarks/latest.json", + "packageCount": 31, + "benchmarkCount": 249, + "failedPackages": 0, + "packages": [ + { + "lane": "native", + "package": "./devtools", + "workspace": "./devtools", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "bucket": "compute", + "samples": [ + { + "iterations": 21114, + "metrics": { + "B/op": 37363, + "allocs/op": 97, + "ns/op": 61685 + }, + "raw": "BenchmarkSanitizeBugCaptureBundleForSupport-20 \t 21114\t 61685 ns/op\t 37363 B/op\t 97 allocs/op" + } + ], + "averageMetrics": { + "B/op": 37363, + "allocs/op": 97, + "ns/op": 61685 + } + }, + { + "name": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "bucket": "memory", + "samples": [ + { + "iterations": 19478, + "metrics": { + "B/op": 41556, + "allocs/op": 110, + "ns/op": 65057 + }, + "raw": "BenchmarkExportSupportDiagnosticBundleJSON-20 \t 19478\t 65057 ns/op\t 41556 B/op\t 110 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41556, + "allocs/op": 110, + "ns/op": 65057 + } + }, + { + "name": "BenchmarkSnapshotNowMicro-20", + "bucket": "memory", + "samples": [ + { + "iterations": 39760113, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 34.3 + }, + "raw": "BenchmarkSnapshotNowMicro-20 \t39760113\t 34.30 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 34.3 + } + }, + { + "name": "BenchmarkCompareSnapshotsMicro-20", + "bucket": "memory", + "samples": [ + { + "iterations": 51999, + "metrics": { + "B/op": 11553, + "allocs/op": 46, + "ns/op": 21582 + }, + "raw": "BenchmarkCompareSnapshotsMicro-20 \t 51999\t 21582 ns/op\t 11553 B/op\t 46 allocs/op" + } + ], + "averageMetrics": { + "B/op": 11553, + "allocs/op": 46, + "ns/op": 21582 + } + } + ] + }, + { + "lane": "native", + "package": "./diagnostics", + "workspace": "./diagnostics", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkNewReport-20", + "bucket": "compute", + "samples": [ + { + "iterations": 96091, + "metrics": { + "B/op": 6494, + "allocs/op": 40, + "ns/op": 13646 + }, + "raw": "BenchmarkNewReport-20 \t 96091\t 13646 ns/op\t 6494 B/op\t 40 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6494, + "allocs/op": 40, + "ns/op": 13646 + } + }, + { + "name": "BenchmarkWriteHTTPError-20", + "bucket": "compute", + "samples": [ + { + "iterations": 124087, + "metrics": { + "B/op": 6444, + "allocs/op": 41, + "ns/op": 17399 + }, + "raw": "BenchmarkWriteHTTPError-20 \t 124087\t 17399 ns/op\t 6444 B/op\t 41 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6444, + "allocs/op": 41, + "ns/op": 17399 + } + }, + { + "name": "BenchmarkNewReportMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 73041, + "metrics": { + "B/op": 6510, + "allocs/op": 42, + "ns/op": 14027 + }, + "raw": "BenchmarkNewReportMicro-20 \t 73041\t 14027 ns/op\t 6510 B/op\t 42 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6510, + "allocs/op": 42, + "ns/op": 14027 + } + } + ] + }, + { + "lane": "native", + "package": "./head", + "workspace": "./head", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkRenderToString-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 32076, + "metrics": { + "B/op": 37000, + "allocs/op": 320, + "ns/op": 37419 + }, + "raw": "BenchmarkRenderToString-20 \t 32076\t 37419 ns/op\t 37000 B/op\t 320 allocs/op" + } + ], + "averageMetrics": { + "B/op": 37000, + "allocs/op": 320, + "ns/op": 37419 + } + }, + { + "name": "BenchmarkRenderJSONLD-20", + "bucket": "memory", + "samples": [ + { + "iterations": 148755, + "metrics": { + "B/op": 9650, + "allocs/op": 45, + "ns/op": 7958 + }, + "raw": "BenchmarkRenderJSONLD-20 \t 148755\t 7958 ns/op\t 9650 B/op\t 45 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9650, + "allocs/op": 45, + "ns/op": 7958 + } + }, + { + "name": "BenchmarkMergeDocumentMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 12104193, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 91.2 + }, + "raw": "BenchmarkMergeDocumentMicro-20 \t12104193\t 91.20 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 91.2 + } + } + ] + }, + { + "lane": "native", + "package": "./hotreload", + "workspace": "./hotreload", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkEnabled-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2047 + }, + "raw": "BenchmarkEnabled-20 \t1000000000\t 0.2047 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2047 + } + }, + { + "name": "BenchmarkEnableDisableCycle-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2321 + }, + "raw": "BenchmarkEnableDisableCycle-20 \t1000000000\t 0.2321 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2321 + } + }, + { + "name": "BenchmarkEnableDisableCycleMicro-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1164 + }, + "raw": "BenchmarkEnableDisableCycleMicro-20 \t1000000000\t 0.1164 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1164 + } + } + ] + }, + { + "lane": "native", + "package": "./html", + "workspace": "./html", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkTagDivWithCommonProps-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1579968, + "metrics": { + "B/op": 1064, + "allocs/op": 18, + "ns/op": 755.4 + }, + "raw": "BenchmarkTagDivWithCommonProps-20 \t 1579968\t 755.4 ns/op\t 1064 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1064, + "allocs/op": 18, + "ns/op": 755.4 + } + }, + { + "name": "BenchmarkCustomElementWithAttributesAndProperties-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1838719, + "metrics": { + "B/op": 912, + "allocs/op": 12, + "ns/op": 656.4 + }, + "raw": "BenchmarkCustomElementWithAttributesAndProperties-20 \t 1838719\t 656.4 ns/op\t 912 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 912, + "allocs/op": 12, + "ns/op": 656.4 + } + }, + { + "name": "BenchmarkDivNodeConstructionMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 2125587, + "metrics": { + "B/op": 872, + "allocs/op": 10, + "ns/op": 673 + }, + "raw": "BenchmarkDivNodeConstructionMicro-20 \t 2125587\t 673.0 ns/op\t 872 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 872, + "allocs/op": 10, + "ns/op": 673 + } + } + ] + }, + { + "lane": "native", + "package": "./html/shorthand", + "workspace": "./html/shorthand", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkTagWithMixedArgs-20", + "bucket": "compute", + "samples": [ + { + "iterations": 641278, + "metrics": { + "B/op": 4160, + "allocs/op": 29, + "ns/op": 1758 + }, + "raw": "BenchmarkTagWithMixedArgs-20 \t 641278\t 1758 ns/op\t 4160 B/op\t 29 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4160, + "allocs/op": 29, + "ns/op": 1758 + } + }, + { + "name": "BenchmarkClassNames-20", + "bucket": "compute", + "samples": [ + { + "iterations": 4289253, + "metrics": { + "B/op": 336, + "allocs/op": 7, + "ns/op": 282.6 + }, + "raw": "BenchmarkClassNames-20 \t 4289253\t 282.6 ns/op\t 336 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 336, + "allocs/op": 7, + "ns/op": 282.6 + } + } + ] + }, + { + "lane": "native", + "package": "./i18n", + "workspace": "./i18n", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkBundleTranslate-20", + "bucket": "compute", + "samples": [ + { + "iterations": 321280, + "metrics": { + "B/op": 3176, + "allocs/op": 46, + "ns/op": 5052 + }, + "raw": "BenchmarkBundleTranslate-20 \t 321280\t 5052 ns/op\t 3176 B/op\t 46 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3176, + "allocs/op": 46, + "ns/op": 5052 + } + }, + { + "name": "BenchmarkNormalizeLocaleMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 2705017, + "metrics": { + "B/op": 244, + "allocs/op": 4, + "ns/op": 441.6 + }, + "raw": "BenchmarkNormalizeLocaleMicro-20 \t 2705017\t 441.6 ns/op\t 244 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 244, + "allocs/op": 4, + "ns/op": 441.6 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "workspace": "./internal/diagnostics", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkBuild-20", + "bucket": "compute", + "samples": [ + { + "iterations": 126206, + "metrics": { + "B/op": 6141, + "allocs/op": 35, + "ns/op": 9819 + }, + "raw": "BenchmarkBuild-20 \t 126206\t 9819 ns/op\t 6141 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6141, + "allocs/op": 35, + "ns/op": 9819 + } + }, + { + "name": "BenchmarkReportFormatted-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1713591, + "metrics": { + "B/op": 1801, + "allocs/op": 16, + "ns/op": 876.3 + }, + "raw": "BenchmarkReportFormatted-20 \t 1713591\t 876.3 ns/op\t 1801 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1801, + "allocs/op": 16, + "ns/op": 876.3 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "workspace": "./internal/platform/mockdom", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1583112, + "metrics": { + "B/op": 1378, + "allocs/op": 7, + "ns/op": 767 + }, + "raw": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20 \t 1583112\t 767.0 ns/op\t 1378 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1378, + "allocs/op": 7, + "ns/op": 767 + } + }, + { + "name": "BenchmarkMockSchedulerFlushAll-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 809524, + "metrics": { + "B/op": 816, + "allocs/op": 27, + "ns/op": 1691 + }, + "raw": "BenchmarkMockSchedulerFlushAll-20 \t 809524\t 1691 ns/op\t 816 B/op\t 27 allocs/op" + } + ], + "averageMetrics": { + "B/op": 816, + "allocs/op": 27, + "ns/op": 1691 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/runtime", + "workspace": "./internal/runtime", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 75, + "benchmarks": [ + { + "name": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 62408, + "metrics": { + "B/op": 42613, + "allocs/op": 146, + "ns/op": 19059 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20 \t 62408\t 19059 ns/op\t 42613 B/op\t 146 allocs/op" + } + ], + "averageMetrics": { + "B/op": 42613, + "allocs/op": 146, + "ns/op": 19059 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 145543, + "metrics": { + "B/op": 33194, + "allocs/op": 8, + "ns/op": 7281 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20 \t 145543\t 7281 ns/op\t 33194 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33194, + "allocs/op": 8, + "ns/op": 7281 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 30595, + "metrics": { + "B/op": 42466, + "allocs/op": 130, + "ns/op": 43051 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20 \t 30595\t 43051 ns/op\t 42466 B/op\t 130 allocs/op" + } + ], + "averageMetrics": { + "B/op": 42466, + "allocs/op": 130, + "ns/op": 43051 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 47626, + "metrics": { + "B/op": 33685, + "allocs/op": 11, + "ns/op": 25676 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20 \t 47626\t 25676 ns/op\t 33685 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33685, + "allocs/op": 11, + "ns/op": 25676 + } + }, + { + "name": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 40609, + "metrics": { + "B/op": 34275, + "allocs/op": 17, + "ns/op": 26082 + }, + "raw": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20 \t 40609\t 26082 ns/op\t 34275 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34275, + "allocs/op": 17, + "ns/op": 26082 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 24692, + "metrics": { + "B/op": 36437, + "allocs/op": 33, + "ns/op": 47365 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20 \t 24692\t 47365 ns/op\t 36437 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 36437, + "allocs/op": 33, + "ns/op": 47365 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 22166, + "metrics": { + "B/op": 36093, + "allocs/op": 33, + "ns/op": 51640 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20 \t 22166\t 51640 ns/op\t 36093 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 36093, + "allocs/op": 33, + "ns/op": 51640 + } + }, + { + "name": "BenchmarkIsNilableTypeCachedPointer-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 132748032, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.147 + }, + "raw": "BenchmarkIsNilableTypeCachedPointer-20 \t132748032\t 9.147 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.147 + } + }, + { + "name": "BenchmarkFastEqualInt-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 771564752, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.564 + }, + "raw": "BenchmarkFastEqualInt-20 \t771564752\t 1.564 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.564 + } + }, + { + "name": "BenchmarkFastEqualString-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 600195963, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.004 + }, + "raw": "BenchmarkFastEqualString-20 \t600195963\t 2.004 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.004 + } + }, + { + "name": "BenchmarkAreDepsEqual3Primitives-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 138337476, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.731 + }, + "raw": "BenchmarkAreDepsEqual3Primitives-20 \t138337476\t 8.731 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.731 + } + }, + { + "name": "BenchmarkGoUseStateIntDirectUpdate-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1799877, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 565.6 + }, + "raw": "BenchmarkGoUseStateIntDirectUpdate-20 \t 1799877\t 565.6 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 565.6 + } + }, + { + "name": "BenchmarkGoUseStatePointerNilReset-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2133846, + "metrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 496.8 + }, + "raw": "BenchmarkGoUseStatePointerNilReset-20 \t 2133846\t 496.8 ns/op\t 436 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 496.8 + } + }, + { + "name": "BenchmarkGoUseMemoSameDeps-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 25921453, + "metrics": { + "B/op": 113, + "allocs/op": 1, + "ns/op": 63.67 + }, + "raw": "BenchmarkGoUseMemoSameDeps-20 \t25921453\t 63.67 ns/op\t 113 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 113, + "allocs/op": 1, + "ns/op": 63.67 + } + }, + { + "name": "BenchmarkGoUseCallbackSameDeps-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 21275161, + "metrics": { + "B/op": 110, + "allocs/op": 1, + "ns/op": 53.28 + }, + "raw": "BenchmarkGoUseCallbackSameDeps-20 \t21275161\t 53.28 ns/op\t 110 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 110, + "allocs/op": 1, + "ns/op": 53.28 + } + }, + { + "name": "BenchmarkGoUseRefStable-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 33875433, + "metrics": { + "B/op": 93, + "allocs/op": 0, + "ns/op": 38.02 + }, + "raw": "BenchmarkGoUseRefStable-20 \t33875433\t 38.02 ns/op\t 93 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 93, + "allocs/op": 0, + "ns/op": 38.02 + } + }, + { + "name": "BenchmarkGoUseIdStable-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 28018659, + "metrics": { + "B/op": 90, + "allocs/op": 0, + "ns/op": 45.46 + }, + "raw": "BenchmarkGoUseIdStable-20 \t28018659\t 45.46 ns/op\t 90 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 90, + "allocs/op": 0, + "ns/op": 45.46 + } + }, + { + "name": "BenchmarkGoUseFuncWrap-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 17889673, + "metrics": { + "B/op": 130, + "allocs/op": 2, + "ns/op": 80.65 + }, + "raw": "BenchmarkGoUseFuncWrap-20 \t17889673\t 80.65 ns/op\t 130 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 130, + "allocs/op": 2, + "ns/op": 80.65 + } + }, + { + "name": "BenchmarkGoUseEffectSameDeps-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 16028444, + "metrics": { + "B/op": 96, + "allocs/op": 1, + "ns/op": 67.35 + }, + "raw": "BenchmarkGoUseEffectSameDeps-20 \t16028444\t 67.35 ns/op\t 96 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 96, + "allocs/op": 1, + "ns/op": 67.35 + } + }, + { + "name": "BenchmarkGoUseFetchStubInit-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1612 + }, + "raw": "BenchmarkGoUseFetchStubInit-20 \t1000000000\t 0.1612 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1612 + } + }, + { + "name": "BenchmarkGoUseFetchStubGetter-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 600134128, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.873 + }, + "raw": "BenchmarkGoUseFetchStubGetter-20 \t600134128\t 1.873 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.873 + } + }, + { + "name": "BenchmarkGoUseFetchStubRefetch-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.042 + }, + "raw": "BenchmarkGoUseFetchStubRefetch-20 \t1000000000\t 1.042 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.042 + } + }, + { + "name": "BenchmarkDivWithTextChildren-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2617741, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 438.8 + }, + "raw": "BenchmarkDivWithTextChildren-20 \t 2617741\t 438.8 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 438.8 + } + }, + { + "name": "BenchmarkDivWithComponents4-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2209809, + "metrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 517.7 + }, + "raw": "BenchmarkDivWithComponents4-20 \t 2209809\t 517.7 ns/op\t 744 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 517.7 + } + }, + { + "name": "BenchmarkWithComponentsGeneric4-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2184901, + "metrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 514.4 + }, + "raw": "BenchmarkWithComponentsGeneric4-20 \t 2184901\t 514.4 ns/op\t 760 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 514.4 + } + }, + { + "name": "BenchmarkHydrateSimpleReuse-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 143458, + "metrics": { + "B/op": 8535, + "allocs/op": 70, + "ns/op": 8571 + }, + "raw": "BenchmarkHydrateSimpleReuse-20 \t 143458\t 8571 ns/op\t 8535 B/op\t 70 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8535, + "allocs/op": 70, + "ns/op": 8571 + } + }, + { + "name": "BenchmarkHydrateTagMismatchFallback-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 98701, + "metrics": { + "B/op": 9209, + "allocs/op": 83, + "ns/op": 11212 + }, + "raw": "BenchmarkHydrateTagMismatchFallback-20 \t 98701\t 11212 ns/op\t 9209 B/op\t 83 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9209, + "allocs/op": 83, + "ns/op": 11212 + } + }, + { + "name": "BenchmarkHydrateMediumTreeReuse-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 2584, + "metrics": { + "B/op": 430804, + "allocs/op": 6020, + "ns/op": 506229 + }, + "raw": "BenchmarkHydrateMediumTreeReuse-20 \t 2584\t 506229 ns/op\t 430804 B/op\t 6020 allocs/op" + } + ], + "averageMetrics": { + "B/op": 430804, + "allocs/op": 6020, + "ns/op": 506229 + } + }, + { + "name": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 2239, + "metrics": { + "B/op": 451294, + "allocs/op": 5759, + "ns/op": 519138 + }, + "raw": "BenchmarkHydrateMediumTreeFirstUpdate-20 \t 2239\t 519138 ns/op\t 451294 B/op\t 5759 allocs/op" + } + ], + "averageMetrics": { + "B/op": 451294, + "allocs/op": 5759, + "ns/op": 519138 + } + }, + { + "name": "BenchmarkDOMNodeInterfaceEquals-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1172 + }, + "raw": "BenchmarkDOMNodeInterfaceEquals-20 \t1000000000\t 0.1172 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1172 + } + }, + { + "name": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 53478556, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 24.29 + }, + "raw": "BenchmarkDOMAdapterInterfaceCreateElement-20 \t53478556\t 24.29 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 24.29 + } + }, + { + "name": "BenchmarkSchedulerInterfaceSetTimeout-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 74154922, + "metrics": { + "B/op": 42, + "allocs/op": 0, + "ns/op": 16.81 + }, + "raw": "BenchmarkSchedulerInterfaceSetTimeout-20 \t74154922\t 16.81 ns/op\t 42 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 42, + "allocs/op": 0, + "ns/op": 16.81 + } + }, + { + "name": "BenchmarkRuntimeLayoutBaselines-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.1648 + }, + "raw": "BenchmarkRuntimeLayoutBaselines-20 \t1000000000\t 0.1648 ns/op\t 64.00 element-bytes\t 40.00 fetchstate-bytes\t 8.000 fiber-align\t 344.0 fiber-bytes\t 8.000 hooks-align\t 424.0 hooks-bytes\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.1648 + } + }, + { + "name": "BenchmarkFiberHotFieldScan256-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6325556, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 197.8 + }, + "raw": "BenchmarkFiberHotFieldScan256-20 \t 6325556\t 197.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 197.8 + } + }, + { + "name": "BenchmarkFiberSiblingWalk256-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4094614, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 310.5 + }, + "raw": "BenchmarkFiberSiblingWalk256-20 \t 4094614\t 310.5 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 310.5 + } + }, + { + "name": "BenchmarkHooksIndexResetHotPath-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 157679586, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.37 + }, + "raw": "BenchmarkHooksIndexResetHotPath-20 \t157679586\t 7.370 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.37 + } + }, + { + "name": "BenchmarkRenderPortalToSelector-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 246619, + "metrics": { + "B/op": 7815, + "allocs/op": 55, + "ns/op": 5103 + }, + "raw": "BenchmarkRenderPortalToSelector-20 \t 246619\t 5103 ns/op\t 7815 B/op\t 55 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7815, + "allocs/op": 55, + "ns/op": 5103 + } + }, + { + "name": "BenchmarkCreateElementHostWithTextChildren-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2919094, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 408.4 + }, + "raw": "BenchmarkCreateElementHostWithTextChildren-20 \t 2919094\t 408.4 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 408.4 + } + }, + { + "name": "BenchmarkPropsEqualChildrenSamePointer-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 23664204, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 51.29 + }, + "raw": "BenchmarkPropsEqualChildrenSamePointer-20 \t23664204\t 51.29 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 51.29 + } + }, + { + "name": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 27260954, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 45.18 + }, + "raw": "BenchmarkPropsEqualChildrenDifferentPointer-20 \t27260954\t 45.18 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 45.18 + } + }, + { + "name": "BenchmarkReconcileChildrenStableList16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 257704, + "metrics": { + "B/op": 5637, + "allocs/op": 16, + "ns/op": 4117 + }, + "raw": "BenchmarkReconcileChildrenStableList16-20 \t 257704\t 4117 ns/op\t 5637 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5637, + "allocs/op": 16, + "ns/op": 4117 + } + }, + { + "name": "BenchmarkReconcileChildrenWithFragments16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 273993, + "metrics": { + "B/op": 5666, + "allocs/op": 17, + "ns/op": 4545 + }, + "raw": "BenchmarkReconcileChildrenWithFragments16-20 \t 273993\t 4545 ns/op\t 5666 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5666, + "allocs/op": 17, + "ns/op": 4545 + } + }, + { + "name": "BenchmarkReconcileChildrenKeyedStableList16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 221014, + "metrics": { + "B/op": 5697, + "allocs/op": 18, + "ns/op": 5474 + }, + "raw": "BenchmarkReconcileChildrenKeyedStableList16-20 \t 221014\t 5474 ns/op\t 5697 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5697, + "allocs/op": 18, + "ns/op": 5474 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1153876, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 1062 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20 \t 1153876\t 1062 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 1062 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 1087 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20 \t 1000000\t 1087 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 1087 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesInitialRender-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1372843, + "metrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 755.5 + }, + "raw": "BenchmarkUpdateDomPropertiesInitialRender-20 \t 1372843\t 755.5 ns/op\t 1120 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 755.5 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesSteadyState-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2161112, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 605.5 + }, + "raw": "BenchmarkUpdateDomPropertiesSteadyState-20 \t 2161112\t 605.5 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 605.5 + } + }, + { + "name": "BenchmarkCommitDeletionDomlessSubtree32-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 103926, + "metrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 11070 + }, + "raw": "BenchmarkCommitDeletionDomlessSubtree32-20 \t 103926\t 11070 ns/op\t 21072 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 11070 + } + }, + { + "name": "BenchmarkCommitWorkPlacementChain16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3456367, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 349.2 + }, + "raw": "BenchmarkCommitWorkPlacementChain16-20 \t 3456367\t 349.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 349.2 + } + }, + { + "name": "BenchmarkRunEffectsChain16-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5210804, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 269.3 + }, + "raw": "BenchmarkRunEffectsChain16-20 \t 5210804\t 269.3 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 269.3 + } + }, + { + "name": "BenchmarkGetGlobalRuntimeLazy-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2754214, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 428.6 + }, + "raw": "BenchmarkGetGlobalRuntimeLazy-20 \t 2754214\t 428.6 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 428.6 + } + }, + { + "name": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2757718, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 506.4 + }, + "raw": "BenchmarkInitGlobalRuntimeAfterLazyGet-20 \t 2757718\t 506.4 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 506.4 + } + }, + { + "name": "BenchmarkRenderTo-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 759127, + "metrics": { + "B/op": 3114, + "allocs/op": 20, + "ns/op": 1635 + }, + "raw": "BenchmarkRenderTo-20 \t 759127\t 1635 ns/op\t 3114 B/op\t 20 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3114, + "allocs/op": 20, + "ns/op": 1635 + } + }, + { + "name": "BenchmarkScheduleUpdate-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 7693387, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 166.1 + }, + "raw": "BenchmarkScheduleUpdate-20 \t 7693387\t 166.1 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 166.1 + } + }, + { + "name": "BenchmarkScheduleUpdateSteadyState-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 7356348, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 156.7 + }, + "raw": "BenchmarkScheduleUpdateSteadyState-20 \t 7356348\t 156.7 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 156.7 + } + }, + { + "name": "BenchmarkScheduleUpdateForFiberDepth32-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 5289982, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 215.2 + }, + "raw": "BenchmarkScheduleUpdateForFiberDepth32-20 \t 5289982\t 215.2 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 215.2 + } + }, + { + "name": "BenchmarkRender-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 165782, + "metrics": { + "B/op": 34170, + "allocs/op": 11, + "ns/op": 10835 + }, + "raw": "BenchmarkRender-20 \t 165782\t 10835 ns/op\t 34170 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34170, + "allocs/op": 11, + "ns/op": 10835 + } + }, + { + "name": "BenchmarkRenderSteadyState-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 160366, + "metrics": { + "B/op": 34169, + "allocs/op": 11, + "ns/op": 9096 + }, + "raw": "BenchmarkRenderSteadyState-20 \t 160366\t 9096 ns/op\t 34169 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34169, + "allocs/op": 11, + "ns/op": 9096 + } + }, + { + "name": "BenchmarkEnqueueUI-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 38700189, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 33.17 + }, + "raw": "BenchmarkEnqueueUI-20 \t38700189\t 33.17 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 33.17 + } + }, + { + "name": "BenchmarkProcessUIQueueBatch64-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 522145, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2162 + }, + "raw": "BenchmarkProcessUIQueueBatch64-20 \t 522145\t 2162 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2162 + } + }, + { + "name": "BenchmarkTransitionListRefresh250-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 6234, + "metrics": { + "B/op": 240726, + "allocs/op": 1787, + "ns/op": 238975 + }, + "raw": "BenchmarkTransitionListRefresh250-20 \t 6234\t 238975 ns/op\t 240726 B/op\t 1787 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240726, + "allocs/op": 1787, + "ns/op": 238975 + } + }, + { + "name": "BenchmarkAtomRegistryInitAtomExisting-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 40308223, + "metrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 29.91 + }, + "raw": "BenchmarkAtomRegistryInitAtomExisting-20 \t40308223\t 29.91 ns/op\t 7 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 29.91 + } + }, + { + "name": "BenchmarkAtomRegistryGetAtom-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 92482698, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.14 + }, + "raw": "BenchmarkAtomRegistryGetAtom-20 \t92482698\t 13.14 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.14 + } + }, + { + "name": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 6670252, + "metrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 178 + }, + "raw": "BenchmarkAtomRegistrySubscribeUnsubscribe-20 \t 6670252\t 178.0 ns/op\t 192 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 178 + } + }, + { + "name": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 3683556, + "metrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 358.3 + }, + "raw": "BenchmarkAtomRegistrySetAtom32Subscribers-20 \t 3683556\t 358.3 ns/op\t 264 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 358.3 + } + }, + { + "name": "BenchmarkGoUseAtomIntUpdate-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2505764, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 413.5 + }, + "raw": "BenchmarkGoUseAtomIntUpdate-20 \t 2505764\t 413.5 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 413.5 + } + }, + { + "name": "BenchmarkGoUseAtomPointerNilReset-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2828482, + "metrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 378.2 + }, + "raw": "BenchmarkGoUseAtomPointerNilReset-20 \t 2828482\t 378.2 ns/op\t 444 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 378.2 + } + }, + { + "name": "BenchmarkGoUseAtomGetter-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 75927980, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.09 + }, + "raw": "BenchmarkGoUseAtomGetter-20 \t75927980\t 14.09 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.09 + } + }, + { + "name": "BenchmarkGoUseAtomStableRerender-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 21518332, + "metrics": { + "B/op": 93, + "allocs/op": 0, + "ns/op": 73.08 + }, + "raw": "BenchmarkGoUseAtomStableRerender-20 \t21518332\t 73.08 ns/op\t 93 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 93, + "allocs/op": 0, + "ns/op": 73.08 + } + }, + { + "name": "BenchmarkCleanupAtomSubscriptions8-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 732824, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1601 + }, + "raw": "BenchmarkCleanupAtomSubscriptions8-20 \t 732824\t 1601 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1601 + } + }, + { + "name": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 775623, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1689 + }, + "raw": "BenchmarkAtomRegistryUnsubscribeMany8-20 \t 775623\t 1689 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1689 + } + }, + { + "name": "BenchmarkFiberAllocation-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 87400998, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.29 + }, + "raw": "BenchmarkFiberAllocation-20 \t87400998\t 13.29 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.29 + } + }, + { + "name": "BenchmarkElementLiteralCreation-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1158 + }, + "raw": "BenchmarkElementLiteralCreation-20 \t1000000000\t 0.1158 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1158 + } + }, + { + "name": "BenchmarkHooksPackedStateRead-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1386 + }, + "raw": "BenchmarkHooksPackedStateRead-20 \t1000000000\t 0.1386 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1386 + } + }, + { + "name": "BenchmarkFetchStateCopy-20", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1152 + }, + "raw": "BenchmarkFetchStateCopy-20 \t1000000000\t 0.1152 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1152 + } + } + ] + }, + { + "lane": "native", + "package": "./interop", + "workspace": "./interop", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkDecodeMapToStruct-20", + "bucket": "memory", + "samples": [ + { + "iterations": 552838, + "metrics": { + "B/op": 1137, + "allocs/op": 29, + "ns/op": 2130 + }, + "raw": "BenchmarkDecodeMapToStruct-20 \t 552838\t 2130 ns/op\t 1137 B/op\t 29 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1137, + "allocs/op": 29, + "ns/op": 2130 + } + }, + { + "name": "BenchmarkInteropErrorString-20", + "bucket": "compute", + "samples": [ + { + "iterations": 7609108, + "metrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 175.8 + }, + "raw": "BenchmarkInteropErrorString-20 \t 7609108\t 175.8 ns/op\t 480 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 175.8 + } + }, + { + "name": "BenchmarkClientCanExchangeMicro-20", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 16740463, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 79.75 + }, + "raw": "BenchmarkClientCanExchangeMicro-20 \t16740463\t 79.75 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 79.75 + } + } + ] + }, + { + "lane": "native", + "package": "./logging", + "workspace": "./logging", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkCloneFieldsSmall-20", + "bucket": "memory", + "samples": [ + { + "iterations": 15652696, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 78.98 + }, + "raw": "BenchmarkCloneFieldsSmall-20 \t15652696\t 78.98 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 78.98 + } + }, + { + "name": "BenchmarkLoggerScope-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.4963 + }, + "raw": "BenchmarkLoggerScope-20 \t1000000000\t 0.4963 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.4963 + } + }, + { + "name": "BenchmarkCloneFieldsMicro-20", + "bucket": "memory", + "samples": [ + { + "iterations": 18599460, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 67.84 + }, + "raw": "BenchmarkCloneFieldsMicro-20 \t18599460\t 67.84 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 67.84 + } + } + ] + }, + { + "lane": "native", + "package": "./plugin", + "workspace": "./plugin", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkEvaluateRouteMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 58146577, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 20.2 + }, + "raw": "BenchmarkEvaluateRouteMicro-20 \t58146577\t 20.20 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 20.2 + } + }, + { + "name": "BenchmarkNewHostWithCapabilities-20", + "bucket": "compute", + "samples": [ + { + "iterations": 6755432, + "metrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 189.5 + }, + "raw": "BenchmarkNewHostWithCapabilities-20 \t 6755432\t 189.5 ns/op\t 592 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 189.5 + } + }, + { + "name": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "bucket": "compute", + "samples": [ + { + "iterations": 57260649, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 23.42 + }, + "raw": "BenchmarkEvaluateRouteWithSingleAllowGuard-20 \t57260649\t 23.42 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 23.42 + } + } + ] + }, + { + "lane": "native", + "package": "./prerender", + "workspace": "./prerender", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkNormalizeRoutePath-20", + "bucket": "compute", + "samples": [ + { + "iterations": 252768871, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.813 + }, + "raw": "BenchmarkNormalizeRoutePath-20 \t252768871\t 4.813 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.813 + } + }, + { + "name": "BenchmarkBuildTargetJSONBootstrap-20", + "bucket": "memory", + "samples": [ + { + "iterations": 2337554, + "metrics": { + "B/op": 408, + "allocs/op": 12, + "ns/op": 619.4 + }, + "raw": "BenchmarkBuildTargetJSONBootstrap-20 \t 2337554\t 619.4 ns/op\t 408 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 408, + "allocs/op": 12, + "ns/op": 619.4 + } + }, + { + "name": "BenchmarkNormalizeRoutePathMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 195995997, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6.098 + }, + "raw": "BenchmarkNormalizeRoutePathMicro-20 \t195995997\t 6.098 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6.098 + } + } + ] + }, + { + "lane": "native", + "package": "./pwa", + "workspace": "./pwa", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 490999, + "metrics": { + "B/op": 2576, + "allocs/op": 24, + "ns/op": 2437 + }, + "raw": "BenchmarkBuildServiceWorkerAssetPlanMicro-20 \t 490999\t 2437 ns/op\t 2576 B/op\t 24 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2576, + "allocs/op": 24, + "ns/op": 2437 + } + }, + { + "name": "BenchmarkMarshalManifestJSON-20", + "bucket": "memory", + "samples": [ + { + "iterations": 1522281, + "metrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 757.4 + }, + "raw": "BenchmarkMarshalManifestJSON-20 \t 1522281\t 757.4 ns/op\t 496 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 757.4 + } + }, + { + "name": "BenchmarkBuildServiceWorkerAssetPlan-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 677839, + "metrics": { + "B/op": 2720, + "allocs/op": 24, + "ns/op": 2493 + }, + "raw": "BenchmarkBuildServiceWorkerAssetPlan-20 \t 677839\t 2493 ns/op\t 2720 B/op\t 24 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2720, + "allocs/op": 24, + "ns/op": 2493 + } + } + ] + }, + { + "lane": "native", + "package": "./router", + "workspace": "./router", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkRouteContractMustHrefForMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1844498, + "metrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 645.6 + }, + "raw": "BenchmarkRouteContractMustHrefForMicro-20 \t 1844498\t 645.6 ns/op\t 952 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 645.6 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/hooks", + "workspace": "./testkit/hooks", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkHarnessStubMethodsMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.116 + }, + "raw": "BenchmarkHarnessStubMethodsMicro-20 \t1000000000\t 0.1160 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.116 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/render", + "workspace": "./testkit/render", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkNewResourceControllerMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 26978299, + "metrics": { + "B/op": 240, + "allocs/op": 1, + "ns/op": 48.18 + }, + "raw": "BenchmarkNewResourceControllerMicro-20 \t26978299\t 48.18 ns/op\t 240 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 1, + "ns/op": 48.18 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/router", + "workspace": "./testkit/router", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkFixtureStubMethodsMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1157 + }, + "raw": "BenchmarkFixtureStubMethodsMicro-20 \t1000000000\t 0.1157 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1157 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/ssr", + "workspace": "./testkit/ssr", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkNormalizeStaticRoutePathMicro-20", + "bucket": "compute", + "samples": [ + { + "iterations": 259177809, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.743 + }, + "raw": "BenchmarkNormalizeStaticRoutePathMicro-20 \t259177809\t 4.743 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.743 + } + } + ] + }, + { + "lane": "native", + "package": "./ui", + "workspace": "./ui", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 8, + "benchmarks": [ + { + "name": "BenchmarkRenderToStringMicro-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 9418012, + "metrics": { + "B/op": 64, + "allocs/op": 3, + "ns/op": 127.9 + }, + "raw": "BenchmarkRenderToStringMicro-20 \t 9418012\t 127.9 ns/op\t 64 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 64, + "allocs/op": 3, + "ns/op": 127.9 + } + }, + { + "name": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "bucket": "memory", + "samples": [ + { + "iterations": 183429, + "metrics": { + "B/op": 5541, + "allocs/op": 81, + "ns/op": 7821 + }, + "raw": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20 \t 183429\t 7821 ns/op\t 5541 B/op\t 81 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5541, + "allocs/op": 81, + "ns/op": 7821 + } + }, + { + "name": "BenchmarkRenderToStringPublicSSRSurface-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 426009, + "metrics": { + "B/op": 4176, + "allocs/op": 55, + "ns/op": 5191 + }, + "raw": "BenchmarkRenderToStringPublicSSRSurface-20 \t 426009\t 5191 ns/op\t 4176 B/op\t 55 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4176, + "allocs/op": 55, + "ns/op": 5191 + } + }, + { + "name": "BenchmarkMarshalSSRBootstrapJSON-20", + "bucket": "memory", + "samples": [ + { + "iterations": 347162, + "metrics": { + "B/op": 3483, + "allocs/op": 43, + "ns/op": 5250 + }, + "raw": "BenchmarkMarshalSSRBootstrapJSON-20 \t 347162\t 5250 ns/op\t 3483 B/op\t 43 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3483, + "allocs/op": 43, + "ns/op": 5250 + } + }, + { + "name": "BenchmarkMarshalSSRBootstrapBinary-20", + "bucket": "memory", + "samples": [ + { + "iterations": 939805, + "metrics": { + "B/op": 402, + "allocs/op": 4, + "ns/op": 1264 + }, + "raw": "BenchmarkMarshalSSRBootstrapBinary-20 \t 939805\t 1264 ns/op\t 402 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 402, + "allocs/op": 4, + "ns/op": 1264 + } + }, + { + "name": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "bucket": "memory", + "samples": [ + { + "iterations": 266293, + "metrics": { + "B/op": 2328, + "allocs/op": 54, + "ns/op": 5016 + }, + "raw": "BenchmarkUnmarshalSSRBootstrapJSON-20 \t 266293\t 5016 ns/op\t 2328 B/op\t 54 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2328, + "allocs/op": 54, + "ns/op": 5016 + } + }, + { + "name": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "bucket": "memory", + "samples": [ + { + "iterations": 358947, + "metrics": { + "B/op": 1976, + "allocs/op": 42, + "ns/op": 3700 + }, + "raw": "BenchmarkUnmarshalSSRBootstrapBinary-20 \t 358947\t 3700 ns/op\t 1976 B/op\t 42 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1976, + "allocs/op": 42, + "ns/op": 3700 + } + }, + { + "name": "BenchmarkRenderBootstrapReferenceScript-20", + "bucket": "memory", + "samples": [ + { + "iterations": 490822, + "metrics": { + "B/op": 1753, + "allocs/op": 19, + "ns/op": 2527 + }, + "raw": "BenchmarkRenderBootstrapReferenceScript-20 \t 490822\t 2527 ns/op\t 1753 B/op\t 19 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1753, + "allocs/op": 19, + "ns/op": 2527 + } + } + ] + }, + { + "lane": "native", + "package": "./virtualization", + "workspace": "./virtualization", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkComputeViewportStateMicro-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 135850798, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.638 + }, + "raw": "BenchmarkComputeViewportStateMicro-20 \t135850798\t 8.638 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.638 + } + }, + { + "name": "BenchmarkComputeViewportState-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 73027792, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.53 + }, + "raw": "BenchmarkComputeViewportState-20 \t73027792\t 16.53 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.53 + } + }, + { + "name": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 65374431, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.63 + }, + "raw": "BenchmarkViewportDiagnosticsWithRowLifecycle-20 \t65374431\t 18.63 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.63 + } + } + ] + }, + { + "lane": "wasm", + "package": "./fetch", + "workspace": "./fetch", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 5, + "benchmarks": [ + { + "name": "BenchmarkResolveMutationQueueOptions", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 37543550, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 30.31 + }, + "raw": "BenchmarkResolveMutationQueueOptions \t37543550\t 30.31 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 30.31 + } + }, + { + "name": "BenchmarkNormalizeMutationID", + "bucket": "compute", + "samples": [ + { + "iterations": 2522071, + "metrics": { + "B/op": 40, + "allocs/op": 2, + "ns/op": 463 + }, + "raw": "BenchmarkNormalizeMutationID \t 2522071\t 463.0 ns/op\t 40 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 40, + "allocs/op": 2, + "ns/op": 463 + } + }, + { + "name": "BenchmarkMergeResolvedMutation", + "bucket": "compute", + "samples": [ + { + "iterations": 609930, + "metrics": { + "B/op": 696, + "allocs/op": 6, + "ns/op": 1898 + }, + "raw": "BenchmarkMergeResolvedMutation \t 609930\t 1898 ns/op\t 696 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 696, + "allocs/op": 6, + "ns/op": 1898 + } + }, + { + "name": "BenchmarkBuildMultipartFormData", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 16602, + "metrics": { + "B/op": 392, + "allocs/op": 35, + "ns/op": 79407 + }, + "raw": "BenchmarkBuildMultipartFormData \t 16602\t 79407 ns/op\t 392 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 392, + "allocs/op": 35, + "ns/op": 79407 + } + }, + { + "name": "BenchmarkNormalizeMutationIDMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 2296483, + "metrics": { + "B/op": 63, + "allocs/op": 2, + "ns/op": 519.5 + }, + "raw": "BenchmarkNormalizeMutationIDMicro \t 2296483\t 519.5 ns/op\t 63 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 63, + "allocs/op": 2, + "ns/op": 519.5 + } + } + ] + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "workspace": "./internal/platform/jsdom", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 13, + "benchmarks": [ + { + "name": "BenchmarkWASMDOMAdapterCreateElement", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 35242, + "metrics": { + "B/op": 248, + "allocs/op": 24, + "ns/op": 31259 + }, + "raw": "BenchmarkWASMDOMAdapterCreateElement \t 35242\t 31259 ns/op\t 248 B/op\t 24 allocs/op" + } + ], + "averageMetrics": { + "B/op": 248, + "allocs/op": 24, + "ns/op": 31259 + } + }, + { + "name": "BenchmarkWASMDOMAdapterSetAttribute", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 70996, + "metrics": { + "B/op": 136, + "allocs/op": 13, + "ns/op": 17130 + }, + "raw": "BenchmarkWASMDOMAdapterSetAttribute \t 70996\t 17130 ns/op\t 136 B/op\t 13 allocs/op" + } + ], + "averageMetrics": { + "B/op": 136, + "allocs/op": 13, + "ns/op": 17130 + } + }, + { + "name": "BenchmarkWASMDOMAdapterAppendChild", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 29313, + "metrics": { + "B/op": 344, + "allocs/op": 33, + "ns/op": 44822 + }, + "raw": "BenchmarkWASMDOMAdapterAppendChild \t 29313\t 44822 ns/op\t 344 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 344, + "allocs/op": 33, + "ns/op": 44822 + } + }, + { + "name": "BenchmarkWASMDOMAdapterQuerySelector", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 34881, + "metrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 42390 + }, + "raw": "BenchmarkWASMDOMAdapterQuerySelector \t 34881\t 42390 ns/op\t 240 B/op\t 23 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 42390 + } + }, + { + "name": "BenchmarkWASMDOMAdapterGetElementById", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 37593, + "metrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 34202 + }, + "raw": "BenchmarkWASMDOMAdapterGetElementById \t 37593\t 34202 ns/op\t 240 B/op\t 23 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 34202 + } + }, + { + "name": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 28255, + "metrics": { + "B/op": 342, + "allocs/op": 27, + "ns/op": 47938 + }, + "raw": "BenchmarkWASMDOMAdapterQuerySelectorAll \t 28255\t 47938 ns/op\t 342 B/op\t 27 allocs/op" + } + ], + "averageMetrics": { + "B/op": 342, + "allocs/op": 27, + "ns/op": 47938 + } + }, + { + "name": "BenchmarkWASMDOMAdapterSetPropertyString", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 742104, + "metrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 2143 + }, + "raw": "BenchmarkWASMDOMAdapterSetPropertyString \t 742104\t 2143 ns/op\t 8 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 2143 + } + }, + { + "name": "BenchmarkWASMDOMAdapterBatchAppend16", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 5012, + "metrics": { + "B/op": 1777, + "allocs/op": 171, + "ns/op": 260206 + }, + "raw": "BenchmarkWASMDOMAdapterBatchAppend16 \t 5012\t 260206 ns/op\t 1777 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1777, + "allocs/op": 171, + "ns/op": 260206 + } + }, + { + "name": "BenchmarkWASMEventAdapterAddRemoveListener", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 53055, + "metrics": { + "B/op": 192, + "allocs/op": 16, + "ns/op": 24845 + }, + "raw": "BenchmarkWASMEventAdapterAddRemoveListener \t 53055\t 24845 ns/op\t 192 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 16, + "ns/op": 24845 + } + }, + { + "name": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 213219, + "metrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6123 + }, + "raw": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke \t 213219\t 6123 ns/op\t 32 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6123 + } + }, + { + "name": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 108282, + "metrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 11593 + }, + "raw": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke \t 108282\t 11593 ns/op\t 80 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 11593 + } + }, + { + "name": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 205993, + "metrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6135 + }, + "raw": "BenchmarkLegacyWrapFunctionNoArgsInvoke \t 205993\t 6135 ns/op\t 32 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6135 + } + }, + { + "name": "BenchmarkLegacyWrapFunctionStringInvoke", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 120808, + "metrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 11603 + }, + "raw": "BenchmarkLegacyWrapFunctionStringInvoke \t 120808\t 11603 ns/op\t 80 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 11603 + } + } + ] + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "workspace": "./internal/runtime", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 82, + "benchmarks": [ + { + "name": "BenchmarkGoEventGetValue", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 339591, + "metrics": { + "B/op": 24, + "allocs/op": 3, + "ns/op": 3391 + }, + "raw": "BenchmarkGoEventGetValue \t 339591\t 3391 ns/op\t 24 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 3, + "ns/op": 3391 + } + }, + { + "name": "BenchmarkGoEventIsChecked", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 690129, + "metrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 1885 + }, + "raw": "BenchmarkGoEventIsChecked \t 690129\t 1885 ns/op\t 8 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 1885 + } + }, + { + "name": "BenchmarkGoEventGetKey", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 718797, + "metrics": { + "B/op": 16, + "allocs/op": 2, + "ns/op": 1892 + }, + "raw": "BenchmarkGoEventGetKey \t 718797\t 1892 ns/op\t 16 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 16, + "allocs/op": 2, + "ns/op": 1892 + } + }, + { + "name": "BenchmarkGoEventGetKeyCode", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4520925, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 266.3 + }, + "raw": "BenchmarkGoEventGetKeyCode \t 4520925\t 266.3 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 266.3 + } + }, + { + "name": "BenchmarkGoEventGetTarget", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 794584, + "metrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 1828 + }, + "raw": "BenchmarkGoEventGetTarget \t 794584\t 1828 ns/op\t 24 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 1828 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 41758, + "allocs/op": 146, + "ns/op": 121554 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16 \t 10000\t 121554 ns/op\t 41758 B/op\t 146 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41758, + "allocs/op": 146, + "ns/op": 121554 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 25738, + "metrics": { + "B/op": 32907, + "allocs/op": 7, + "ns/op": 45453 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16 \t 25738\t 45453 ns/op\t 32907 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32907, + "allocs/op": 7, + "ns/op": 45453 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 41650, + "allocs/op": 130, + "ns/op": 110139 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16 \t 10000\t 110139 ns/op\t 41650 B/op\t 130 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41650, + "allocs/op": 130, + "ns/op": 110139 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 26296, + "metrics": { + "B/op": 32970, + "allocs/op": 11, + "ns/op": 51018 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16 \t 26296\t 51018 ns/op\t 32970 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32970, + "allocs/op": 11, + "ns/op": 51018 + } + }, + { + "name": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 17398, + "metrics": { + "B/op": 33312, + "allocs/op": 17, + "ns/op": 69047 + }, + "raw": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16 \t 17398\t 69047 ns/op\t 33312 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33312, + "allocs/op": 17, + "ns/op": 69047 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 9454, + "metrics": { + "B/op": 35023, + "allocs/op": 32, + "ns/op": 202738 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64 \t 9454\t 202738 ns/op\t 35023 B/op\t 32 allocs/op" + } + ], + "averageMetrics": { + "B/op": 35023, + "allocs/op": 32, + "ns/op": 202738 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 9774, + "metrics": { + "B/op": 35051, + "allocs/op": 32, + "ns/op": 208565 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64 \t 9774\t 208565 ns/op\t 35051 B/op\t 32 allocs/op" + } + ], + "averageMetrics": { + "B/op": 35051, + "allocs/op": 32, + "ns/op": 208565 + } + }, + { + "name": "BenchmarkIsNilableTypeCachedPointer", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 11543832, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 103.1 + }, + "raw": "BenchmarkIsNilableTypeCachedPointer \t11543832\t 103.1 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 103.1 + } + }, + { + "name": "BenchmarkFastEqualInt", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 137078557, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.019 + }, + "raw": "BenchmarkFastEqualInt \t137078557\t 9.019 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.019 + } + }, + { + "name": "BenchmarkFastEqualString", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 81466483, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.91 + }, + "raw": "BenchmarkFastEqualString \t81466483\t 13.91 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.91 + } + }, + { + "name": "BenchmarkAreDepsEqual3Primitives", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 31726960, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 37.17 + }, + "raw": "BenchmarkAreDepsEqual3Primitives \t31726960\t 37.17 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 37.17 + } + }, + { + "name": "BenchmarkGoUseStateIntDirectUpdate", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1245783, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 916.7 + }, + "raw": "BenchmarkGoUseStateIntDirectUpdate \t 1245783\t 916.7 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 916.7 + } + }, + { + "name": "BenchmarkGoUseStatePointerNilReset", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1616229, + "metrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 724.5 + }, + "raw": "BenchmarkGoUseStatePointerNilReset \t 1616229\t 724.5 ns/op\t 436 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 724.5 + } + }, + { + "name": "BenchmarkGoUseMemoSameDeps", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4467799, + "metrics": { + "B/op": 110, + "allocs/op": 1, + "ns/op": 333.1 + }, + "raw": "BenchmarkGoUseMemoSameDeps \t 4467799\t 333.1 ns/op\t 110 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 110, + "allocs/op": 1, + "ns/op": 333.1 + } + }, + { + "name": "BenchmarkGoUseCallbackSameDeps", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4806750, + "metrics": { + "B/op": 103, + "allocs/op": 1, + "ns/op": 296.2 + }, + "raw": "BenchmarkGoUseCallbackSameDeps \t 4806750\t 296.2 ns/op\t 103 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 103, + "allocs/op": 1, + "ns/op": 296.2 + } + }, + { + "name": "BenchmarkGoUseRefStable", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 7795660, + "metrics": { + "B/op": 84, + "allocs/op": 0, + "ns/op": 171 + }, + "raw": "BenchmarkGoUseRefStable \t 7795660\t 171.0 ns/op\t 84 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 84, + "allocs/op": 0, + "ns/op": 171 + } + }, + { + "name": "BenchmarkGoUseIdStable", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6500836, + "metrics": { + "B/op": 81, + "allocs/op": 0, + "ns/op": 184.8 + }, + "raw": "BenchmarkGoUseIdStable \t 6500836\t 184.8 ns/op\t 81 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 81, + "allocs/op": 0, + "ns/op": 184.8 + } + }, + { + "name": "BenchmarkGoUseFuncWrap", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2875527, + "metrics": { + "B/op": 133, + "allocs/op": 2, + "ns/op": 488.6 + }, + "raw": "BenchmarkGoUseFuncWrap \t 2875527\t 488.6 ns/op\t 133 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 133, + "allocs/op": 2, + "ns/op": 488.6 + } + }, + { + "name": "BenchmarkGoUseEffectSameDeps", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4603965, + "metrics": { + "B/op": 107, + "allocs/op": 1, + "ns/op": 319.9 + }, + "raw": "BenchmarkGoUseEffectSameDeps \t 4603965\t 319.9 ns/op\t 107 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 107, + "allocs/op": 1, + "ns/op": 319.9 + } + }, + { + "name": "BenchmarkGoUseFetchInit", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1745217, + "metrics": { + "B/op": 680, + "allocs/op": 5, + "ns/op": 679.9 + }, + "raw": "BenchmarkGoUseFetchInit \t 1745217\t 679.9 ns/op\t 680 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 680, + "allocs/op": 5, + "ns/op": 679.9 + } + }, + { + "name": "BenchmarkGoUseFetchRefetchUnavailable", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 79, + "metrics": { + "B/op": 82, + "allocs/op": 3, + "ns/op": 15573766 + }, + "raw": "BenchmarkGoUseFetchRefetchUnavailable \t 79\t 15573766 ns/op\t 82 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 82, + "allocs/op": 3, + "ns/op": 15573766 + } + }, + { + "name": "BenchmarkDivWithTextChildren", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1083 + }, + "raw": "BenchmarkDivWithTextChildren \t 1000000\t 1083 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1083 + } + }, + { + "name": "BenchmarkDivWithComponents4", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 1197 + }, + "raw": "BenchmarkDivWithComponents4 \t 1000000\t 1197 ns/op\t 744 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 1197 + } + }, + { + "name": "BenchmarkWithComponentsGeneric4", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 942380, + "metrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 1265 + }, + "raw": "BenchmarkWithComponentsGeneric4 \t 942380\t 1265 ns/op\t 760 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 1265 + } + }, + { + "name": "BenchmarkHydrateSimpleReuse", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 38162, + "metrics": { + "B/op": 8520, + "allocs/op": 70, + "ns/op": 31339 + }, + "raw": "BenchmarkHydrateSimpleReuse \t 38162\t 31339 ns/op\t 8520 B/op\t 70 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8520, + "allocs/op": 70, + "ns/op": 31339 + } + }, + { + "name": "BenchmarkHydrateTagMismatchFallback", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 24121, + "metrics": { + "B/op": 9192, + "allocs/op": 83, + "ns/op": 45623 + }, + "raw": "BenchmarkHydrateTagMismatchFallback \t 24121\t 45623 ns/op\t 9192 B/op\t 83 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9192, + "allocs/op": 83, + "ns/op": 45623 + } + }, + { + "name": "BenchmarkHydrateMediumTreeReuse", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 654, + "metrics": { + "B/op": 430011, + "allocs/op": 6019, + "ns/op": 2455990 + }, + "raw": "BenchmarkHydrateMediumTreeReuse \t 654\t 2455990 ns/op\t 430011 B/op\t 6019 allocs/op" + } + ], + "averageMetrics": { + "B/op": 430011, + "allocs/op": 6019, + "ns/op": 2455990 + } + }, + { + "name": "BenchmarkHydrateMediumTreeFirstUpdate", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 657, + "metrics": { + "B/op": 450353, + "allocs/op": 5757, + "ns/op": 1800377 + }, + "raw": "BenchmarkHydrateMediumTreeFirstUpdate \t 657\t 1800377 ns/op\t 450353 B/op\t 5757 allocs/op" + } + ], + "averageMetrics": { + "B/op": 450353, + "allocs/op": 5757, + "ns/op": 1800377 + } + }, + { + "name": "BenchmarkDOMNodeInterfaceEquals", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5068 + }, + "raw": "BenchmarkDOMNodeInterfaceEquals \t1000000000\t 0.5068 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5068 + } + }, + { + "name": "BenchmarkDOMAdapterInterfaceCreateElement", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 25498546, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 46.31 + }, + "raw": "BenchmarkDOMAdapterInterfaceCreateElement \t25498546\t 46.31 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 46.31 + } + }, + { + "name": "BenchmarkSchedulerInterfaceSetTimeout", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 5166427, + "metrics": { + "B/op": 41, + "allocs/op": 0, + "ns/op": 211.8 + }, + "raw": "BenchmarkSchedulerInterfaceSetTimeout \t 5166427\t 211.8 ns/op\t 41 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41, + "allocs/op": 0, + "ns/op": 211.8 + } + }, + { + "name": "BenchmarkRuntimeLayoutBaselines", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.5084 + }, + "raw": "BenchmarkRuntimeLayoutBaselines \t1000000000\t 0.5084 ns/op\t 64.00 element-bytes\t 40.00 fetchstate-bytes\t 8.000 fiber-align\t 344.0 fiber-bytes\t 8.000 hooks-align\t 424.0 hooks-bytes\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.5084 + } + }, + { + "name": "BenchmarkFiberHotFieldScan256", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1775166, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 682.2 + }, + "raw": "BenchmarkFiberHotFieldScan256 \t 1775166\t 682.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 682.2 + } + }, + { + "name": "BenchmarkFiberSiblingWalk256", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3871071, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 308.7 + }, + "raw": "BenchmarkFiberSiblingWalk256 \t 3871071\t 308.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 308.7 + } + }, + { + "name": "BenchmarkHooksIndexResetHotPath", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 132947268, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.956 + }, + "raw": "BenchmarkHooksIndexResetHotPath \t132947268\t 8.956 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.956 + } + }, + { + "name": "BenchmarkRenderPortalToSelector", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 42434, + "metrics": { + "B/op": 7792, + "allocs/op": 55, + "ns/op": 29988 + }, + "raw": "BenchmarkRenderPortalToSelector \t 42434\t 29988 ns/op\t 7792 B/op\t 55 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7792, + "allocs/op": 55, + "ns/op": 29988 + } + }, + { + "name": "BenchmarkCreateElementHostWithTextChildren", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 905586, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1377 + }, + "raw": "BenchmarkCreateElementHostWithTextChildren \t 905586\t 1377 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1377 + } + }, + { + "name": "BenchmarkPropsEqualChildrenSamePointer", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6744477, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 181 + }, + "raw": "BenchmarkPropsEqualChildrenSamePointer \t 6744477\t 181.0 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 181 + } + }, + { + "name": "BenchmarkPropsEqualChildrenDifferentPointer", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 7889010, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 149.5 + }, + "raw": "BenchmarkPropsEqualChildrenDifferentPointer \t 7889010\t 149.5 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 149.5 + } + }, + { + "name": "BenchmarkReconcileChildrenStableList16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 80888, + "metrics": { + "B/op": 5632, + "allocs/op": 16, + "ns/op": 16325 + }, + "raw": "BenchmarkReconcileChildrenStableList16 \t 80888\t 16325 ns/op\t 5632 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5632, + "allocs/op": 16, + "ns/op": 16325 + } + }, + { + "name": "BenchmarkReconcileChildrenWithFragments16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 62174, + "metrics": { + "B/op": 5656, + "allocs/op": 17, + "ns/op": 23857 + }, + "raw": "BenchmarkReconcileChildrenWithFragments16 \t 62174\t 23857 ns/op\t 5656 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5656, + "allocs/op": 17, + "ns/op": 23857 + } + }, + { + "name": "BenchmarkReconcileChildrenKeyedStableList16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 53167, + "metrics": { + "B/op": 5681, + "allocs/op": 18, + "ns/op": 23232 + }, + "raw": "BenchmarkReconcileChildrenKeyedStableList16 \t 53167\t 23232 ns/op\t 5681 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5681, + "allocs/op": 18, + "ns/op": 23232 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 293460, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 4152 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf \t 293460\t 4152 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 4152 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 322248, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 3821 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf \t 322248\t 3821 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 3821 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesInitialRender", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 608481, + "metrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 2243 + }, + "raw": "BenchmarkUpdateDomPropertiesInitialRender \t 608481\t 2243 ns/op\t 1120 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 2243 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesSteadyState", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 844518, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1423 + }, + "raw": "BenchmarkUpdateDomPropertiesSteadyState \t 844518\t 1423 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1423 + } + }, + { + "name": "BenchmarkCommitDeletionDomlessSubtree32", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 38290, + "metrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 32648 + }, + "raw": "BenchmarkCommitDeletionDomlessSubtree32 \t 38290\t 32648 ns/op\t 21072 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 32648 + } + }, + { + "name": "BenchmarkCommitWorkPlacementChain16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 263984, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4659 + }, + "raw": "BenchmarkCommitWorkPlacementChain16 \t 263984\t 4659 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4659 + } + }, + { + "name": "BenchmarkRunEffectsChain16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 284228, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4111 + }, + "raw": "BenchmarkRunEffectsChain16 \t 284228\t 4111 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4111 + } + }, + { + "name": "BenchmarkGetGlobalRuntimeLazy", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1306089, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 948.7 + }, + "raw": "BenchmarkGetGlobalRuntimeLazy \t 1306089\t 948.7 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 948.7 + } + }, + { + "name": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 923462, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 1108 + }, + "raw": "BenchmarkInitGlobalRuntimeAfterLazyGet \t 923462\t 1108 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 1108 + } + }, + { + "name": "BenchmarkRenderTo", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 183928, + "metrics": { + "B/op": 3112, + "allocs/op": 20, + "ns/op": 7107 + }, + "raw": "BenchmarkRenderTo \t 183928\t 7107 ns/op\t 3112 B/op\t 20 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3112, + "allocs/op": 20, + "ns/op": 7107 + } + }, + { + "name": "BenchmarkScheduleUpdate", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 2578446, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 469.4 + }, + "raw": "BenchmarkScheduleUpdate \t 2578446\t 469.4 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 469.4 + } + }, + { + "name": "BenchmarkScheduleUpdateSteadyState", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 2509635, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 539.7 + }, + "raw": "BenchmarkScheduleUpdateSteadyState \t 2509635\t 539.7 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 539.7 + } + }, + { + "name": "BenchmarkScheduleUpdateForFiberDepth32", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1759396, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 694.2 + }, + "raw": "BenchmarkScheduleUpdateForFiberDepth32 \t 1759396\t 694.2 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 694.2 + } + }, + { + "name": "BenchmarkRender", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 44965, + "metrics": { + "B/op": 34008, + "allocs/op": 11, + "ns/op": 30166 + }, + "raw": "BenchmarkRender \t 44965\t 30166 ns/op\t 34008 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34008, + "allocs/op": 11, + "ns/op": 30166 + } + }, + { + "name": "BenchmarkRenderSteadyState", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 42296, + "metrics": { + "B/op": 33996, + "allocs/op": 11, + "ns/op": 27179 + }, + "raw": "BenchmarkRenderSteadyState \t 42296\t 27179 ns/op\t 33996 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33996, + "allocs/op": 11, + "ns/op": 27179 + } + }, + { + "name": "BenchmarkEnqueueUI", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 12859447, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 91.63 + }, + "raw": "BenchmarkEnqueueUI \t12859447\t 91.63 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 91.63 + } + }, + { + "name": "BenchmarkProcessUIQueueBatch64", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 236452, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4977 + }, + "raw": "BenchmarkProcessUIQueueBatch64 \t 236452\t 4977 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4977 + } + }, + { + "name": "BenchmarkTransitionListRefresh250", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1096, + "metrics": { + "B/op": 231734, + "allocs/op": 1788, + "ns/op": 1177886 + }, + "raw": "BenchmarkTransitionListRefresh250 \t 1096\t 1177886 ns/op\t 231734 B/op\t 1788 allocs/op" + } + ], + "averageMetrics": { + "B/op": 231734, + "allocs/op": 1788, + "ns/op": 1177886 + } + }, + { + "name": "BenchmarkTextShim", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5125 + }, + "raw": "BenchmarkTextShim \t1000000000\t 0.5125 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5125 + } + }, + { + "name": "BenchmarkGoUseStateGlobalInit", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 1024, + "allocs/op": 7, + "ns/op": 1094 + }, + "raw": "BenchmarkGoUseStateGlobalInit \t 1000000\t 1094 ns/op\t 1024 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1024, + "allocs/op": 7, + "ns/op": 1094 + } + }, + { + "name": "BenchmarkGoUseAtomGlobalInit", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 675470, + "metrics": { + "B/op": 1152, + "allocs/op": 9, + "ns/op": 5243 + }, + "raw": "BenchmarkGoUseAtomGlobalInit \t 675470\t 5243 ns/op\t 1152 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1152, + "allocs/op": 9, + "ns/op": 5243 + } + }, + { + "name": "BenchmarkAtomRegistryInitAtomExisting", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 14612180, + "metrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 84.41 + }, + "raw": "BenchmarkAtomRegistryInitAtomExisting \t14612180\t 84.41 ns/op\t 7 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 84.41 + } + }, + { + "name": "BenchmarkAtomRegistryGetAtom", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 35483138, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 35.16 + }, + "raw": "BenchmarkAtomRegistryGetAtom \t35483138\t 35.16 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 35.16 + } + }, + { + "name": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1595508, + "metrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 773.6 + }, + "raw": "BenchmarkAtomRegistrySubscribeUnsubscribe \t 1595508\t 773.6 ns/op\t 192 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 773.6 + } + }, + { + "name": "BenchmarkAtomRegistrySetAtom32Subscribers", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 998040, + "metrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 2889 + }, + "raw": "BenchmarkAtomRegistrySetAtom32Subscribers \t 998040\t 2889 ns/op\t 264 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 2889 + } + }, + { + "name": "BenchmarkGoUseAtomIntUpdate", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 891295, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 1529 + }, + "raw": "BenchmarkGoUseAtomIntUpdate \t 891295\t 1529 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 1529 + } + }, + { + "name": "BenchmarkGoUseAtomPointerNilReset", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 897214, + "metrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 1404 + }, + "raw": "BenchmarkGoUseAtomPointerNilReset \t 897214\t 1404 ns/op\t 444 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 1404 + } + }, + { + "name": "BenchmarkGoUseAtomGetter", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 27508156, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 41.35 + }, + "raw": "BenchmarkGoUseAtomGetter \t27508156\t 41.35 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 41.35 + } + }, + { + "name": "BenchmarkGoUseAtomStableRerender", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3670438, + "metrics": { + "B/op": 92, + "allocs/op": 0, + "ns/op": 357 + }, + "raw": "BenchmarkGoUseAtomStableRerender \t 3670438\t 357.0 ns/op\t 92 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 92, + "allocs/op": 0, + "ns/op": 357 + } + }, + { + "name": "BenchmarkCleanupAtomSubscriptions8", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 230364, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 5255 + }, + "raw": "BenchmarkCleanupAtomSubscriptions8 \t 230364\t 5255 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 5255 + } + }, + { + "name": "BenchmarkAtomRegistryUnsubscribeMany8", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 234993, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 5182 + }, + "raw": "BenchmarkAtomRegistryUnsubscribeMany8 \t 234993\t 5182 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 5182 + } + }, + { + "name": "BenchmarkFiberAllocation", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 29698735, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 40.34 + }, + "raw": "BenchmarkFiberAllocation \t29698735\t 40.34 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 40.34 + } + }, + { + "name": "BenchmarkElementLiteralCreation", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.6343 + }, + "raw": "BenchmarkElementLiteralCreation \t1000000000\t 0.6343 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.6343 + } + }, + { + "name": "BenchmarkHooksPackedStateRead", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.7038 + }, + "raw": "BenchmarkHooksPackedStateRead \t1000000000\t 0.7038 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.7038 + } + }, + { + "name": "BenchmarkFetchStateCopy", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5498 + }, + "raw": "BenchmarkFetchStateCopy \t1000000000\t 0.5498 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5498 + } + } + ] + }, + { + "lane": "wasm", + "package": "./interop", + "workspace": "./interop", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 5, + "benchmarks": [ + { + "name": "BenchmarkDecodeMapToStruct", + "bucket": "memory", + "samples": [ + { + "iterations": 105081, + "metrics": { + "B/op": 1136, + "allocs/op": 29, + "ns/op": 9636 + }, + "raw": "BenchmarkDecodeMapToStruct \t 105081\t 9636 ns/op\t 1136 B/op\t 29 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1136, + "allocs/op": 29, + "ns/op": 9636 + } + }, + { + "name": "BenchmarkInteropErrorString", + "bucket": "compute", + "samples": [ + { + "iterations": 2119359, + "metrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 568.8 + }, + "raw": "BenchmarkInteropErrorString \t 2119359\t 568.8 ns/op\t 480 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 568.8 + } + }, + { + "name": "BenchmarkLocalStorageGetItem", + "bucket": "compute", + "samples": [ + { + "iterations": 78192, + "metrics": { + "B/op": 96, + "allocs/op": 10, + "ns/op": 15649 + }, + "raw": "BenchmarkLocalStorageGetItem \t 78192\t 15649 ns/op\t 96 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 96, + "allocs/op": 10, + "ns/op": 15649 + } + }, + { + "name": "BenchmarkModuleCall", + "bucket": "compute", + "samples": [ + { + "iterations": 84393, + "metrics": { + "B/op": 128, + "allocs/op": 11, + "ns/op": 13157 + }, + "raw": "BenchmarkModuleCall \t 84393\t 13157 ns/op\t 128 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 128, + "allocs/op": 11, + "ns/op": 13157 + } + }, + { + "name": "BenchmarkClientCanExchangeMicro", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 4477371, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 271.3 + }, + "raw": "BenchmarkClientCanExchangeMicro \t 4477371\t 271.3 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 271.3 + } + } + ] + }, + { + "lane": "wasm", + "package": "./router", + "workspace": "./router", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkRouteContractMustHrefForMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 460879, + "metrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 2756 + }, + "raw": "BenchmarkRouteContractMustHrefForMicro \t 460879\t 2756 ns/op\t 952 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 2756 + } + }, + { + "name": "BenchmarkResolveRouteStackNestedLayout", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 300276, + "metrics": { + "B/op": 1808, + "allocs/op": 15, + "ns/op": 3372 + }, + "raw": "BenchmarkResolveRouteStackNestedLayout \t 300276\t 3372 ns/op\t 1808 B/op\t 15 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1808, + "allocs/op": 15, + "ns/op": 3372 + } + }, + { + "name": "BenchmarkCurrentNestedLayoutRoute", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1080, + "metrics": { + "B/op": 12191, + "allocs/op": 685, + "ns/op": 1043946 + }, + "raw": "BenchmarkCurrentNestedLayoutRoute \t 1080\t 1043946 ns/op\t 12191 B/op\t 685 allocs/op" + } + ], + "averageMetrics": { + "B/op": 12191, + "allocs/op": 685, + "ns/op": 1043946 + } + }, + { + "name": "BenchmarkEvaluateNavigationNestedLayouts", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 37836, + "metrics": { + "B/op": 3552, + "allocs/op": 41, + "ns/op": 31420 + }, + "raw": "BenchmarkEvaluateNavigationNestedLayouts \t 37836\t 31420 ns/op\t 3552 B/op\t 41 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3552, + "allocs/op": 41, + "ns/op": 31420 + } + } + ] + }, + { + "lane": "wasm", + "package": "./state", + "workspace": "./state", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkMarshalSnapshotJSONMicro", + "bucket": "memory", + "samples": [ + { + "iterations": 309265, + "metrics": { + "B/op": 448, + "allocs/op": 13, + "ns/op": 3788 + }, + "raw": "BenchmarkMarshalSnapshotJSONMicro \t 309265\t 3788 ns/op\t 448 B/op\t 13 allocs/op" + } + ], + "averageMetrics": { + "B/op": 448, + "allocs/op": 13, + "ns/op": 3788 + } + }, + { + "name": "BenchmarkUnmarshalSnapshotJSONMicro", + "bucket": "memory", + "samples": [ + { + "iterations": 171841, + "metrics": { + "B/op": 1656, + "allocs/op": 25, + "ns/op": 8170 + }, + "raw": "BenchmarkUnmarshalSnapshotJSONMicro \t 171841\t 8170 ns/op\t 1656 B/op\t 25 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1656, + "allocs/op": 25, + "ns/op": 8170 + } + }, + { + "name": "BenchmarkSnapshotSelect", + "bucket": "memory", + "samples": [ + { + "iterations": 4684080, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 256.1 + }, + "raw": "BenchmarkSnapshotSelect \t 4684080\t 256.1 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 256.1 + } + }, + { + "name": "BenchmarkMarshalUnmarshalSnapshotJSON", + "bucket": "memory", + "samples": [ + { + "iterations": 80619, + "metrics": { + "B/op": 1528, + "allocs/op": 38, + "ns/op": 19129 + }, + "raw": "BenchmarkMarshalUnmarshalSnapshotJSON \t 80619\t 19129 ns/op\t 1528 B/op\t 38 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1528, + "allocs/op": 38, + "ns/op": 19129 + } + } + ] + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "workspace": "./testkit/hooks", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkRenderHookCurrentMicroWasm", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 276801631, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.24 + }, + "raw": "BenchmarkRenderHookCurrentMicroWasm \t276801631\t 4.240 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.24 + } + }, + { + "name": "BenchmarkRenderHookStateRerenderMicroWasm", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 19225, + "metrics": { + "B/op": 68208, + "allocs/op": 35, + "ns/op": 57362 + }, + "raw": "BenchmarkRenderHookStateRerenderMicroWasm \t 19225\t 57362 ns/op\t 68208 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 68208, + "allocs/op": 35, + "ns/op": 57362 + } + } + ] + }, + { + "lane": "wasm", + "package": "./testkit/router", + "workspace": "./testkit/router", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkCloneURLValuesMicroWasm", + "bucket": "memory", + "samples": [ + { + "iterations": 2478117, + "metrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 498.6 + }, + "raw": "BenchmarkCloneURLValuesMicroWasm \t 2478117\t 498.6 ns/op\t 48 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 498.6 + } + }, + { + "name": "BenchmarkCloneStringMapMicroWasm", + "bucket": "memory", + "samples": [ + { + "iterations": 7148346, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 167.1 + }, + "raw": "BenchmarkCloneStringMapMicroWasm \t 7148346\t 167.1 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 167.1 + } + } + ] + }, + { + "lane": "wasm", + "package": "./utils", + "workspace": "./utils", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 308664736, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.884 + }, + "raw": "BenchmarkConfigureAndReadMemStatsSampleRateMicro \t308664736\t 3.884 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.884 + } + }, + { + "name": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 1944000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 600.8 + }, + "raw": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro \t 1944000\t 600.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 600.8 + } + } + ] + } + ], + "scores": { + "method": "100 * geometric_mean(reference_ns / measured_ns)", + "referencePath": "./docs/benchmarks/reference.json", + "referenceGeneratedAt": "2026-03-25T15:17:41Z", + "referenceMachine": "go1.26.0 windows/amd64", + "matchedBenchmarks": 249, + "overallScore": 100.6, + "buckets": [ + { + "id": "compute", + "label": "Compute", + "matchedBenchmarks": 36, + "score": 97.3 + }, + { + "id": "memory", + "label": "Memory", + "matchedBenchmarks": 22, + "score": 97.8 + }, + { + "id": "alloc_runtime", + "label": "Alloc/Runtime", + "matchedBenchmarks": 132, + "score": 102.2 + }, + { + "id": "sync_concurrency", + "label": "Sync/Concurrency", + "matchedBenchmarks": 28, + "score": 104.6 + }, + { + "id": "end_to_end", + "label": "End-to-End", + "matchedBenchmarks": 31, + "score": 101.1 + } + ] + }, + "comparison": { + "baselineGeneratedAt": "2026-03-25T15:17:41Z", + "tolerancePct": 2, + "matchedMetrics": 747, + "improved": 109, + "regressed": 114, + "unchanged": 524, + "entries": [ + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "metric": "ns/op", + "baseline": 11512, + "current": 25676, + "delta": 14164, + "deltaPct": 123.03683113273107, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "metric": "ns/op", + "baseline": 26564, + "current": 43051, + "delta": 16487, + "deltaPct": 62.06520102394217, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps-20", + "metric": "ns/op", + "baseline": 42.1, + "current": 67.35, + "delta": 25.249999999999993, + "deltaPct": 59.97624703087884, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkBuildTargetJSONBootstrap-20", + "metric": "ns/op", + "baseline": 395.8, + "current": 619.4, + "delta": 223.59999999999997, + "deltaPct": 56.49317837291561, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGlobalInit", + "metric": "ns/op", + "baseline": 3454, + "current": 5243, + "delta": 1789, + "deltaPct": 51.79502026635785, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState-20", + "metric": "ns/op", + "baseline": 399.2, + "current": 605.5, + "delta": 206.3, + "deltaPct": 51.67835671342685, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkBundleTranslate-20", + "metric": "ns/op", + "baseline": 3338, + "current": 5052, + "delta": 1714, + "deltaPct": 51.348112642300784, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookStateRerenderMicroWasm", + "metric": "ns/op", + "baseline": 109077, + "current": 57362, + "delta": -51715, + "deltaPct": -47.411461628024234, + "direction": "improved" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkWriteHTTPError-20", + "metric": "ns/op", + "baseline": 31498, + "current": 17399, + "delta": -14099, + "deltaPct": -44.76157216331196, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines-20", + "metric": "ns/op", + "baseline": 0.1144, + "current": 0.1648, + "delta": 0.0504, + "deltaPct": 44.05594405594406, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "metric": "ns/op", + "baseline": 1179, + "current": 1689, + "delta": 510, + "deltaPct": 43.25699745547074, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubInit-20", + "metric": "ns/op", + "baseline": 0.114, + "current": 0.1612, + "delta": 0.047200000000000006, + "deltaPct": 41.40350877192983, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "metric": "ns/op", + "baseline": 7045, + "current": 4152, + "delta": -2893, + "deltaPct": -41.064584811923346, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneStringMapMicroWasm", + "metric": "ns/op", + "baseline": 281.9, + "current": 167.1, + "delta": -114.79999999999998, + "deltaPct": -40.72366087264987, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback", + "metric": "ns/op", + "baseline": 76790, + "current": 45623, + "delta": -31167, + "deltaPct": -40.58731605677823, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchInit", + "metric": "ns/op", + "baseline": 1118, + "current": 679.9, + "delta": -438.1, + "deltaPct": -39.18604651162791, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookCurrentMicroWasm", + "metric": "ns/op", + "baseline": 6.882, + "current": 4.24, + "delta": -2.6419999999999995, + "deltaPct": -38.39000290613193, + "direction": "improved" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePathMicro-20", + "metric": "ns/op", + "baseline": 4.418, + "current": 6.098, + "delta": 1.6799999999999997, + "deltaPct": 38.026256224535985, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender-20", + "metric": "ns/op", + "baseline": 7882, + "current": 10835, + "delta": 2953, + "deltaPct": 37.46511037807663, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "metric": "ns/op", + "baseline": 1774, + "current": 2437, + "delta": 663, + "deltaPct": 37.37316798196167, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals", + "metric": "ns/op", + "baseline": 0.8077, + "current": 0.5068, + "delta": -0.30089999999999995, + "deltaPct": -37.25393091494366, + "direction": "improved" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkNormalizeLocaleMicro-20", + "metric": "ns/op", + "baseline": 323.7, + "current": 441.6, + "delta": 117.90000000000003, + "deltaPct": 36.422613531047276, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState", + "metric": "ns/op", + "baseline": 42658, + "current": 27179, + "delta": -15479, + "deltaPct": -36.286276899995315, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset", + "metric": "ns/op", + "baseline": 1132, + "current": 724.5, + "delta": -407.5, + "deltaPct": -35.99823321554771, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMEventAdapterAddRemoveListener", + "metric": "ns/op", + "baseline": 37881, + "current": 24845, + "delta": -13036, + "deltaPct": -34.4130302790317, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalUnmarshalSnapshotJSON", + "metric": "ns/op", + "baseline": 14264, + "current": 19129, + "delta": 4865, + "deltaPct": 34.106842400448684, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8-20", + "metric": "ns/op", + "baseline": 1197, + "current": 1601, + "delta": 404, + "deltaPct": 33.751044277360066, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32", + "metric": "ns/op", + "baseline": 49053, + "current": 32648, + "delta": -16405, + "deltaPct": -33.443418343424455, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneURLValuesMicroWasm", + "metric": "ns/op", + "baseline": 742.1, + "current": 498.6, + "delta": -243.5, + "deltaPct": -32.812289448861335, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState", + "metric": "ns/op", + "baseline": 2105, + "current": 1423, + "delta": -682, + "deltaPct": -32.39904988123515, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubGetter-20", + "metric": "ns/op", + "baseline": 1.424, + "current": 1.873, + "delta": 0.44900000000000007, + "deltaPct": 31.5308988764045, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16", + "metric": "ns/op", + "baseline": 6658, + "current": 4659, + "delta": -1999, + "deltaPct": -30.024031240612796, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps", + "metric": "ns/op", + "baseline": 451.9, + "current": 319.9, + "delta": -132, + "deltaPct": -29.210002212878955, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate", + "metric": "ns/op", + "baseline": 2516709, + "current": 1800377, + "delta": -716332, + "deltaPct": -28.463044396471744, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy", + "metric": "ns/op", + "baseline": 1319, + "current": 948.7, + "delta": -370.29999999999995, + "deltaPct": -28.074298711144802, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse-20", + "metric": "ns/op", + "baseline": 396136, + "current": 506229, + "delta": 110093, + "deltaPct": 27.791717995839814, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4", + "metric": "ns/op", + "baseline": 1739, + "current": 1265, + "delta": -474, + "deltaPct": -27.257044278320876, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback-20", + "metric": "ns/op", + "baseline": 8880, + "current": 11212, + "delta": 2332, + "deltaPct": 26.26126126126126, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64", + "metric": "ns/op", + "baseline": 6745, + "current": 4977, + "delta": -1768, + "deltaPct": -26.212008895478135, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16", + "metric": "ns/op", + "baseline": 5519, + "current": 4111, + "delta": -1408, + "deltaPct": -25.51186809204566, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender-20", + "metric": "ns/op", + "baseline": 58.29, + "current": 73.08, + "delta": 14.79, + "deltaPct": 25.37313432835821, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "metric": "ns/op", + "baseline": 799.7, + "current": 600.8, + "delta": -198.9000000000001, + "deltaPct": -24.87182693510067, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead-20", + "metric": "ns/op", + "baseline": 0.1112, + "current": 0.1386, + "delta": 0.027400000000000008, + "deltaPct": 24.64028776978418, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead", + "metric": "ns/op", + "baseline": 0.5656, + "current": 0.7038, + "delta": 0.1382, + "deltaPct": 24.434229137199434, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterBatchAppend16", + "metric": "ns/op", + "baseline": 342044, + "current": 260206, + "delta": -81838, + "deltaPct": -23.926161546467707, + "direction": "improved" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderJSONLD-20", + "metric": "ns/op", + "baseline": 10408, + "current": 7958, + "delta": -2450, + "deltaPct": -23.53958493466564, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "metric": "ns/op", + "baseline": 21123, + "current": 26082, + "delta": 4959, + "deltaPct": 23.476778866638263, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse", + "metric": "ns/op", + "baseline": 40888, + "current": 31339, + "delta": -9549, + "deltaPct": -23.35404030522403, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren-20", + "metric": "ns/op", + "baseline": 331.4, + "current": 408.4, + "delta": 77, + "deltaPct": 23.234761617380812, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250", + "metric": "ns/op", + "baseline": 1526483, + "current": 1177886, + "delta": -348597, + "deltaPct": -22.83661200288506, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelector", + "metric": "ns/op", + "baseline": 34559, + "current": 42390, + "delta": 7831, + "deltaPct": 22.659799184004168, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePath-20", + "metric": "ns/op", + "baseline": 3.924, + "current": 4.813, + "delta": 0.8889999999999998, + "deltaPct": 22.655453618756365, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "metric": "ns/op", + "baseline": 4929, + "current": 3821, + "delta": -1108, + "deltaPct": -22.479204706837088, + "direction": "improved" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "metric": "ns/op", + "baseline": 10071, + "current": 7821, + "delta": -2250, + "deltaPct": -22.34137622877569, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateGlobalInit", + "metric": "ns/op", + "baseline": 1408, + "current": 1094, + "delta": -314, + "deltaPct": -22.301136363636363, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "metric": "ns/op", + "baseline": 39267, + "current": 47938, + "delta": 8671, + "deltaPct": 22.082155499528866, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate", + "metric": "ns/op", + "baseline": 1959, + "current": 1529, + "delta": -430, + "deltaPct": -21.949974476773864, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTextShim", + "metric": "ns/op", + "baseline": 0.6564, + "current": 0.5125, + "delta": -0.14390000000000003, + "deltaPct": -21.922608165752592, + "direction": "improved" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSnapshotNowMicro-20", + "metric": "ns/op", + "baseline": 28.14, + "current": 34.3, + "delta": 6.159999999999997, + "deltaPct": 21.89054726368158, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse", + "metric": "ns/op", + "baseline": 3135983, + "current": 2455990, + "delta": -679993, + "deltaPct": -21.683567799952996, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout", + "metric": "ns/op", + "baseline": 269.6, + "current": 211.8, + "delta": -57.80000000000001, + "deltaPct": -21.43916913946588, + "direction": "improved" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReport-20", + "metric": "ns/op", + "baseline": 11260, + "current": 13646, + "delta": 2386, + "deltaPct": 21.190053285968027, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "metric": "ns/op", + "baseline": 877, + "current": 1062, + "delta": 185, + "deltaPct": 21.094640820980615, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkCompareSnapshotsMicro-20", + "metric": "ns/op", + "baseline": 17959, + "current": 21582, + "delta": 3623, + "deltaPct": 20.17372904950164, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkReportFormatted-20", + "metric": "ns/op", + "baseline": 729.7, + "current": 876.3, + "delta": 146.5999999999999, + "deltaPct": 20.09044812936822, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement", + "metric": "ns/op", + "baseline": 57.54, + "current": 46.31, + "delta": -11.229999999999997, + "deltaPct": -19.516857838025718, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationIDMicro", + "metric": "ns/op", + "baseline": 645.1, + "current": 519.5, + "delta": -125.60000000000002, + "deltaPct": -19.4698496357154, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation", + "metric": "ns/op", + "baseline": 0.5322, + "current": 0.6343, + "delta": 0.10209999999999997, + "deltaPct": 19.18451709883502, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8", + "metric": "ns/op", + "baseline": 6383, + "current": 5182, + "delta": -1201, + "deltaPct": -18.81560394798684, + "direction": "improved" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkMergeDocumentMicro-20", + "metric": "ns/op", + "baseline": 77.13, + "current": 91.2, + "delta": 14.070000000000007, + "deltaPct": 18.241929210423972, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender-20", + "metric": "ns/op", + "baseline": 640.5, + "current": 755.5, + "delta": 115, + "deltaPct": 17.95472287275566, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate-20", + "metric": "ns/op", + "baseline": 480.9, + "current": 565.6, + "delta": 84.70000000000005, + "deltaPct": 17.612809315866095, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap", + "metric": "ns/op", + "baseline": 592.2, + "current": 488.6, + "delta": -103.60000000000002, + "deltaPct": -17.49408983451537, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "metric": "ns/op", + "baseline": 252300, + "current": 208565, + "delta": -43735, + "deltaPct": -17.334522393975426, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct", + "metric": "ns/op", + "baseline": 11579, + "current": 9636, + "delta": -1943, + "deltaPct": -16.78037827100786, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation-20", + "metric": "ns/op", + "baseline": 11.4, + "current": 13.29, + "delta": 1.8899999999999988, + "deltaPct": 16.57894736842104, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI", + "metric": "ns/op", + "baseline": 109.8, + "current": 91.63, + "delta": -18.17, + "deltaPct": -16.54826958105647, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16", + "metric": "ns/op", + "baseline": 20499, + "current": 23857, + "delta": 3358, + "deltaPct": 16.381286892043516, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting", + "metric": "ns/op", + "baseline": 100.9, + "current": 84.41, + "delta": -16.49000000000001, + "deltaPct": -16.342913776015866, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkUnmarshalSnapshotJSONMicro", + "metric": "ns/op", + "baseline": 7052, + "current": 8170, + "delta": 1118, + "deltaPct": 15.853658536585366, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo", + "metric": "ns/op", + "baseline": 8436, + "current": 7107, + "delta": -1329, + "deltaPct": -15.753911806543385, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString", + "metric": "ns/op", + "baseline": 674.9, + "current": 568.8, + "delta": -106.10000000000002, + "deltaPct": -15.720847532967852, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64-20", + "metric": "ns/op", + "baseline": 1869, + "current": 2162, + "delta": 293, + "deltaPct": 15.676832530765115, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt", + "metric": "ns/op", + "baseline": 10.61, + "current": 9.019, + "delta": -1.5909999999999993, + "deltaPct": -14.995287464655979, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset", + "metric": "ns/op", + "baseline": 1651, + "current": 1404, + "delta": -247, + "deltaPct": -14.960629921259844, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout", + "metric": "B/op", + "baseline": 48, + "current": 41, + "delta": -7, + "deltaPct": -14.583333333333334, + "direction": "improved" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReportMicro-20", + "metric": "ns/op", + "baseline": 12243, + "current": 14027, + "delta": 1784, + "deltaPct": 14.571591930082494, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderBootstrapReferenceScript-20", + "metric": "ns/op", + "baseline": 2207, + "current": 2527, + "delta": 320, + "deltaPct": 14.499320344358857, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16-20", + "metric": "ns/op", + "baseline": 235.3, + "current": 269.3, + "delta": 34, + "deltaPct": 14.449638759031025, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "metric": "ns/op", + "baseline": 3234, + "current": 3700, + "delta": 466, + "deltaPct": 14.40940012368584, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsMicro-20", + "metric": "ns/op", + "baseline": 59.38, + "current": 67.84, + "delta": 8.46, + "deltaPct": 14.247221286628495, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout-20", + "metric": "ns/op", + "baseline": 14.72, + "current": 16.81, + "delta": 2.089999999999998, + "deltaPct": 14.198369565217378, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate", + "metric": "ns/op", + "baseline": 1063, + "current": 916.7, + "delta": -146.29999999999995, + "deltaPct": -13.762935089369705, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren", + "metric": "ns/op", + "baseline": 1255, + "current": 1083, + "delta": -172, + "deltaPct": -13.705179282868526, + "direction": "improved" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "metric": "ns/op", + "baseline": 20.61, + "current": 23.42, + "delta": 2.8100000000000023, + "deltaPct": 13.634158175642902, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender", + "metric": "ns/op", + "baseline": 34791, + "current": 30166, + "delta": -4625, + "deltaPct": -13.293667902618495, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset-20", + "metric": "ns/op", + "baseline": 334, + "current": 378.2, + "delta": 44.19999999999999, + "deltaPct": 13.233532934131734, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./testkit/ssr", + "benchmark": "BenchmarkNormalizeStaticRoutePathMicro-20", + "metric": "ns/op", + "baseline": 5.447, + "current": 4.743, + "delta": -0.7039999999999997, + "deltaPct": -12.92454562144299, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkBuildMultipartFormData", + "metric": "ns/op", + "baseline": 91062, + "current": 79407, + "delta": -11655, + "deltaPct": -12.798972128879225, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting-20", + "metric": "B/op", + "baseline": 8, + "current": 7, + "delta": -1, + "deltaPct": -12.5, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset-20", + "metric": "ns/op", + "baseline": 441.9, + "current": 496.8, + "delta": 54.900000000000034, + "deltaPct": 12.423625254582493, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4-20", + "metric": "ns/op", + "baseline": 588.9, + "current": 517.7, + "delta": -71.19999999999993, + "deltaPct": -12.090337918152477, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "metric": "ns/op", + "baseline": 451.8, + "current": 506.4, + "delta": 54.599999999999966, + "deltaPct": 12.084993359893751, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "metric": "ns/op", + "baseline": 4478, + "current": 5016, + "delta": 538, + "deltaPct": 12.014292094685128, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable", + "metric": "ns/op", + "baseline": 209.9, + "current": 184.8, + "delta": -25.099999999999994, + "deltaPct": -11.958075273939968, + "direction": "improved" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringMicro-20", + "metric": "ns/op", + "baseline": 144.4, + "current": 127.9, + "delta": -16.5, + "deltaPct": -11.426592797783933, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState-20", + "metric": "ns/op", + "baseline": 176.9, + "current": 156.7, + "delta": -20.200000000000017, + "deltaPct": -11.41888072357265, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16", + "metric": "ns/op", + "baseline": 26206, + "current": 23232, + "delta": -2974, + "deltaPct": -11.348546134473022, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkModuleCall", + "metric": "ns/op", + "baseline": 11827, + "current": 13157, + "delta": 1330, + "deltaPct": 11.245455314111778, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetPropertyString", + "metric": "ns/op", + "baseline": 1929, + "current": 2143, + "delta": 214, + "deltaPct": 11.093831000518403, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "metric": "ns/op", + "baseline": 46576, + "current": 51640, + "delta": 5064, + "deltaPct": 10.872552387495706, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkLocalStorageGetItem", + "metric": "ns/op", + "baseline": 14119, + "current": 15649, + "delta": 1530, + "deltaPct": 10.836461505772363, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap", + "metric": "B/op", + "baseline": 120, + "current": 133, + "delta": 13, + "deltaPct": 10.833333333333334, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse-20", + "metric": "ns/op", + "baseline": 7738, + "current": 8571, + "delta": 833, + "deltaPct": 10.765055569914708, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender", + "metric": "ns/op", + "baseline": 2512, + "current": 2243, + "delta": -269, + "deltaPct": -10.70859872611465, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "metric": "ns/op", + "baseline": 21.98, + "current": 24.29, + "delta": 2.3099999999999987, + "deltaPct": 10.509554140127381, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter", + "metric": "ns/op", + "baseline": 46.19, + "current": 41.35, + "delta": -4.839999999999996, + "deltaPct": -10.478458540809692, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockSchedulerFlushAll-20", + "metric": "ns/op", + "baseline": 1887, + "current": 1691, + "delta": -196, + "deltaPct": -10.386857445680974, + "direction": "improved" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString-20", + "metric": "ns/op", + "baseline": 159.3, + "current": 175.8, + "delta": 16.5, + "deltaPct": 10.357815442561206, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate", + "metric": "ns/op", + "baseline": 523.5, + "current": 469.4, + "delta": -54.10000000000002, + "deltaPct": -10.33428844317097, + "direction": "improved" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkClassNames-20", + "metric": "ns/op", + "baseline": 314.2, + "current": 282.6, + "delta": -31.599999999999966, + "deltaPct": -10.057288351368545, + "direction": "improved" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsSmall-20", + "metric": "ns/op", + "baseline": 71.79, + "current": 78.98, + "delta": 7.189999999999998, + "deltaPct": 10.015322468310346, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "metric": "allocs/op", + "baseline": 10, + "current": 11, + "delta": 1, + "deltaPct": 10, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "metric": "ns/op", + "baseline": 988.9, + "current": 1087, + "delta": 98.10000000000002, + "deltaPct": 9.920113257154417, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "metric": "ns/op", + "baseline": 4.311, + "current": 3.884, + "delta": -0.42700000000000005, + "deltaPct": -9.904894456042683, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom", + "metric": "ns/op", + "baseline": 39.02, + "current": 35.16, + "delta": -3.8600000000000065, + "deltaPct": -9.892362890825233, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "metric": "ns/op", + "baseline": 6646, + "current": 7281, + "delta": 635, + "deltaPct": 9.554619319891664, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "metric": "ns/op", + "baseline": 134323, + "current": 121554, + "delta": -12769, + "deltaPct": -9.506190302479842, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap-20", + "metric": "ns/op", + "baseline": 73.7, + "current": 80.65, + "delta": 6.950000000000003, + "deltaPct": 9.430122116689283, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4", + "metric": "ns/op", + "baseline": 1320, + "current": 1197, + "delta": -123, + "deltaPct": -9.318181818181818, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps", + "metric": "B/op", + "baseline": 98, + "current": 107, + "delta": 9, + "deltaPct": 9.183673469387756, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16", + "metric": "ns/op", + "baseline": 17975, + "current": 16325, + "delta": -1650, + "deltaPct": -9.17941585535466, + "direction": "improved" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlan-20", + "metric": "ns/op", + "baseline": 2288, + "current": 2493, + "delta": 205, + "deltaPct": 8.95979020979021, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate-20", + "metric": "ns/op", + "baseline": 379.6, + "current": 413.5, + "delta": 33.89999999999998, + "deltaPct": 8.930453108535295, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps-20", + "metric": "B/op", + "baseline": 101, + "current": 110, + "delta": 9, + "deltaPct": 8.91089108910891, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkNewHostWithCapabilities-20", + "metric": "ns/op", + "baseline": 174.1, + "current": 189.5, + "delta": 15.400000000000006, + "deltaPct": 8.845491097070653, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationID", + "metric": "ns/op", + "baseline": 425.6, + "current": 463, + "delta": 37.39999999999998, + "deltaPct": 8.787593984962399, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy-20", + "metric": "ns/op", + "baseline": 468.9, + "current": 428.6, + "delta": -40.299999999999955, + "deltaPct": -8.594583066751964, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "metric": "ns/op", + "baseline": 49607, + "current": 45453, + "delta": -4154, + "deltaPct": -8.373818211139557, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkCurrentNestedLayoutRoute", + "metric": "ns/op", + "baseline": 1136635, + "current": 1043946, + "delta": -92689, + "deltaPct": -8.154684661302882, + "direction": "improved" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkMarshalManifestJSON-20", + "metric": "ns/op", + "baseline": 700.4, + "current": 757.4, + "delta": 57, + "deltaPct": 8.138206739006282, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation", + "metric": "ns/op", + "baseline": 43.91, + "current": 40.34, + "delta": -3.569999999999993, + "deltaPct": -8.130266454110666, + "direction": "improved" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro-20", + "metric": "ns/op", + "baseline": 73.87, + "current": 79.75, + "delta": 5.8799999999999955, + "deltaPct": 7.959929606064701, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct-20", + "metric": "ns/op", + "baseline": 1980, + "current": 2130, + "delta": 150, + "deltaPct": 7.575757575757576, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionStringInvoke", + "metric": "ns/op", + "baseline": 10787, + "current": 11603, + "delta": 816, + "deltaPct": 7.564661166218596, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "metric": "ns/op", + "baseline": 483564, + "current": 519138, + "delta": 35574, + "deltaPct": 7.356627044196838, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector", + "metric": "ns/op", + "baseline": 32331, + "current": 29988, + "delta": -2343, + "deltaPct": -7.246914725804955, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256", + "metric": "ns/op", + "baseline": 733.8, + "current": 682.2, + "delta": -51.59999999999991, + "deltaPct": -7.0318887980376, + "direction": "improved" + }, + { + "lane": "native", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro-20", + "metric": "ns/op", + "baseline": 603.3, + "current": 645.6, + "delta": 42.30000000000007, + "deltaPct": 7.011437095972164, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable", + "metric": "B/op", + "baseline": 87, + "current": 81, + "delta": -6, + "deltaPct": -6.896551724137931, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer", + "metric": "ns/op", + "baseline": 160.5, + "current": 149.5, + "delta": -11, + "deltaPct": -6.853582554517133, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "metric": "ns/op", + "baseline": 74074, + "current": 69047, + "delta": -5027, + "deltaPct": -6.786456786456786, + "direction": "improved" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "metric": "ns/op", + "baseline": 60927, + "current": 65057, + "delta": 4130, + "deltaPct": 6.778603903031496, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState-20", + "metric": "ns/op", + "baseline": 9748, + "current": 9096, + "delta": -652, + "deltaPct": -6.688551497743127, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout-20", + "metric": "B/op", + "baseline": 45, + "current": 42, + "delta": -3, + "deltaPct": -6.666666666666667, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkMergeResolvedMutation", + "metric": "ns/op", + "baseline": 2033, + "current": 1898, + "delta": -135, + "deltaPct": -6.640432857845549, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo-20", + "metric": "ns/op", + "baseline": 1751, + "current": 1635, + "delta": -116, + "deltaPct": -6.624785836664763, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkResolveMutationQueueOptions", + "metric": "ns/op", + "baseline": 28.64, + "current": 30.31, + "delta": 1.6699999999999982, + "deltaPct": 5.831005586592172, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender", + "metric": "B/op", + "baseline": 87, + "current": 92, + "delta": 5, + "deltaPct": 5.747126436781609, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycleMicro-20", + "metric": "ns/op", + "baseline": 0.1102, + "current": 0.1164, + "delta": 0.006199999999999997, + "deltaPct": 5.626134301270415, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers", + "metric": "ns/op", + "baseline": 2737, + "current": 2889, + "delta": 152, + "deltaPct": 5.5535257581293385, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16-20", + "metric": "ns/op", + "baseline": 369.7, + "current": 349.2, + "delta": -20.5, + "deltaPct": -5.545036516094131, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "metric": "ns/op", + "baseline": 12273, + "current": 11593, + "delta": -680, + "deltaPct": -5.540617615904832, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "metric": "ns/op", + "baseline": 6480, + "current": 6123, + "delta": -357, + "deltaPct": -5.5092592592592595, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterAppendChild", + "metric": "ns/op", + "baseline": 47405, + "current": 44822, + "delta": -2583, + "deltaPct": -5.448792321485076, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8", + "metric": "ns/op", + "baseline": 5556, + "current": 5255, + "delta": -301, + "deltaPct": -5.417566594672426, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalSnapshotJSONMicro", + "metric": "ns/op", + "baseline": 4002, + "current": 3788, + "delta": -214, + "deltaPct": -5.347326336831585, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256-20", + "metric": "ns/op", + "baseline": 294.8, + "current": 310.5, + "delta": 15.699999999999989, + "deltaPct": 5.325644504748978, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringPublicSSRSurface-20", + "metric": "ns/op", + "baseline": 4929, + "current": 5191, + "delta": 262, + "deltaPct": 5.315479813349564, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps", + "metric": "ns/op", + "baseline": 351.6, + "current": 333.1, + "delta": -18.5, + "deltaPct": -5.261660978384527, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer", + "metric": "ns/op", + "baseline": 108.8, + "current": 103.1, + "delta": -5.700000000000003, + "deltaPct": -5.238970588235297, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren", + "metric": "ns/op", + "baseline": 1453, + "current": 1377, + "delta": -76, + "deltaPct": -5.230557467309016, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState", + "metric": "ns/op", + "baseline": 513.1, + "current": 539.7, + "delta": 26.600000000000023, + "deltaPct": 5.184174624829472, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps-20", + "metric": "B/op", + "baseline": 101, + "current": 96, + "delta": -5, + "deltaPct": -4.9504950495049505, + "direction": "improved" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "metric": "ns/op", + "baseline": 58799, + "current": 61685, + "delta": 2886, + "deltaPct": 4.908246738890117, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapJSON-20", + "metric": "ns/op", + "baseline": 5019, + "current": 5250, + "delta": 231, + "deltaPct": 4.602510460251046, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./testkit/render", + "benchmark": "BenchmarkNewResourceControllerMicro-20", + "metric": "ns/op", + "baseline": 46.08, + "current": 48.18, + "delta": 2.1000000000000014, + "deltaPct": 4.55729166666667, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32", + "metric": "ns/op", + "baseline": 727.3, + "current": 694.2, + "delta": -33.09999999999991, + "deltaPct": -4.551079334524943, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "metric": "ns/op", + "baseline": 43.25, + "current": 45.18, + "delta": 1.9299999999999997, + "deltaPct": 4.462427745664739, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps-20", + "metric": "ns/op", + "baseline": 61.01, + "current": 63.67, + "delta": 2.6600000000000037, + "deltaPct": 4.359940993279796, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkCustomElementWithAttributesAndProperties-20", + "metric": "ns/op", + "baseline": 686.2, + "current": 656.4, + "delta": -29.800000000000068, + "deltaPct": -4.342757213640348, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "metric": "ns/op", + "baseline": 211598, + "current": 202738, + "delta": -8860, + "deltaPct": -4.1871851340749915, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer-20", + "metric": "ns/op", + "baseline": 49.24, + "current": 51.29, + "delta": 2.049999999999997, + "deltaPct": 4.163281884646622, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "metric": "ns/op", + "baseline": 53190, + "current": 51018, + "delta": -2172, + "deltaPct": -4.0834743372814435, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256-20", + "metric": "ns/op", + "baseline": 190.2, + "current": 197.8, + "delta": 7.600000000000023, + "deltaPct": 3.995793901156689, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetTarget", + "metric": "ns/op", + "baseline": 1903, + "current": 1828, + "delta": -75, + "deltaPct": -3.9411455596426697, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKeyCode", + "metric": "ns/op", + "baseline": 276.7, + "current": 266.3, + "delta": -10.399999999999977, + "deltaPct": -3.758583303216472, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender", + "metric": "ns/op", + "baseline": 344.1, + "current": 357, + "delta": 12.899999999999977, + "deltaPct": 3.748910200523097, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkResolveRouteStackNestedLayout", + "metric": "ns/op", + "baseline": 3503, + "current": 3372, + "delta": -131, + "deltaPct": -3.7396517270910645, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "metric": "ns/op", + "baseline": 1151, + "current": 1108, + "delta": -43, + "deltaPct": -3.735881841876629, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "metric": "ns/op", + "baseline": 114382, + "current": 110139, + "delta": -4243, + "deltaPct": -3.7094997464636044, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "metric": "ns/op", + "baseline": 45690, + "current": 47365, + "delta": 1675, + "deltaPct": 3.666010067848544, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterGetElementById", + "metric": "ns/op", + "baseline": 33020, + "current": 34202, + "delta": 1182, + "deltaPct": 3.579648697758934, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16-20", + "metric": "ns/op", + "baseline": 3977, + "current": 4117, + "delta": 140, + "deltaPct": 3.52024138798089, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps-20", + "metric": "ns/op", + "baseline": 51.47, + "current": 53.28, + "delta": 1.8100000000000023, + "deltaPct": 3.5166116184185006, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./testkit/router", + "benchmark": "BenchmarkFixtureStubMethodsMicro-20", + "metric": "ns/op", + "baseline": 0.1199, + "current": 0.1157, + "delta": -0.004200000000000009, + "deltaPct": -3.502919099249382, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer", + "metric": "ns/op", + "baseline": 187.3, + "current": 181, + "delta": -6.300000000000011, + "deltaPct": -3.3635878270154893, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives-20", + "metric": "ns/op", + "baseline": 8.448, + "current": 8.731, + "delta": 0.2829999999999995, + "deltaPct": 3.349905303030297, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable-20", + "metric": "ns/op", + "baseline": 44, + "current": 45.46, + "delta": 1.4600000000000009, + "deltaPct": 3.31818181818182, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4-20", + "metric": "ns/op", + "baseline": 531.4, + "current": 514.4, + "delta": -17, + "deltaPct": -3.1990967256304104, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable-20", + "metric": "B/op", + "baseline": 96, + "current": 93, + "delta": -3, + "deltaPct": -3.125, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy-20", + "metric": "ns/op", + "baseline": 0.1118, + "current": 0.1152, + "delta": 0.0034000000000000002, + "deltaPct": 3.041144901610018, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapBinary-20", + "metric": "ns/op", + "baseline": 1227, + "current": 1264, + "delta": 37, + "deltaPct": 3.015484922575387, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16-20", + "metric": "ns/op", + "baseline": 5314, + "current": 5474, + "delta": 160, + "deltaPct": 3.0109145652992093, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy", + "metric": "ns/op", + "baseline": 0.534, + "current": 0.5498, + "delta": 0.015799999999999925, + "deltaPct": 2.9588014981273267, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath-20", + "metric": "ns/op", + "baseline": 7.159, + "current": 7.37, + "delta": 0.2110000000000003, + "deltaPct": 2.9473390138287514, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation-20", + "metric": "ns/op", + "baseline": 0.1125, + "current": 0.1158, + "delta": 0.0032999999999999974, + "deltaPct": 2.933333333333331, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines", + "metric": "ns/op", + "baseline": 0.5231, + "current": 0.5084, + "delta": -0.014700000000000046, + "deltaPct": -2.8101701395526755, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals-20", + "metric": "ns/op", + "baseline": 0.114, + "current": 0.1172, + "delta": 0.0031999999999999945, + "deltaPct": 2.8070175438596445, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycle-20", + "metric": "ns/op", + "baseline": 0.2259, + "current": 0.2321, + "delta": 0.006200000000000011, + "deltaPct": 2.7445772465692837, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderToString-20", + "metric": "ns/op", + "baseline": 36431, + "current": 37419, + "delta": 988, + "deltaPct": 2.7119760643408086, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "metric": "B/op", + "baseline": 333, + "current": 342, + "delta": 9, + "deltaPct": 2.7027027027027026, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps", + "metric": "ns/op", + "baseline": 304.2, + "current": 296.2, + "delta": -8, + "deltaPct": -2.629848783694938, + "direction": "improved" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnabled-20", + "metric": "ns/op", + "baseline": 0.1996, + "current": 0.2047, + "delta": 0.005099999999999993, + "deltaPct": 2.5551102204408784, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate-20", + "metric": "ns/op", + "baseline": 170.4, + "current": 166.1, + "delta": -4.300000000000011, + "deltaPct": -2.5234741784037626, + "direction": "improved" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "metric": "ns/op", + "baseline": 19.1, + "current": 18.63, + "delta": -0.4700000000000024, + "deltaPct": -2.460732984293206, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "metric": "ns/op", + "baseline": 6288, + "current": 6135, + "delta": -153, + "deltaPct": -2.433206106870229, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetAttribute", + "metric": "ns/op", + "baseline": 16730, + "current": 17130, + "delta": 400, + "deltaPct": 2.3909145248057384, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap-20", + "metric": "B/op", + "baseline": 133, + "current": 130, + "delta": -3, + "deltaPct": -2.2556390977443606, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector-20", + "metric": "ns/op", + "baseline": 4993, + "current": 5103, + "delta": 110, + "deltaPct": 2.2030843180452635, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "metric": "ns/op", + "baseline": 18650, + "current": 19059, + "delta": 409, + "deltaPct": 2.193029490616622, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkBuild-20", + "metric": "ns/op", + "baseline": 9609, + "current": 9819, + "delta": 210, + "deltaPct": 2.1854511395566654, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkDivNodeConstructionMicro-20", + "metric": "ns/op", + "baseline": 659, + "current": 673, + "delta": 14, + "deltaPct": 2.12443095599393, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro", + "metric": "ns/op", + "baseline": 2812, + "current": 2756, + "delta": -56, + "deltaPct": -1.991465149359886, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkEvaluateNavigationNestedLayouts", + "metric": "ns/op", + "baseline": 30824, + "current": 31420, + "delta": 596, + "deltaPct": 1.9335582662860107, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "metric": "ns/op", + "baseline": 174.8, + "current": 178, + "delta": 3.1999999999999886, + "deltaPct": 1.8306636155606342, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "metric": "B/op", + "baseline": 1354, + "current": 1378, + "delta": 24, + "deltaPct": 1.7725258493353029, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkTagWithMixedArgs-20", + "metric": "ns/op", + "baseline": 1789, + "current": 1758, + "delta": -31, + "deltaPct": -1.732811626607043, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro", + "metric": "ns/op", + "baseline": 266.7, + "current": 271.3, + "delta": 4.600000000000023, + "deltaPct": 1.724784401949765, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKey", + "metric": "ns/op", + "baseline": 1861, + "current": 1892, + "delta": 31, + "deltaPct": 1.6657710908113916, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteMicro-20", + "metric": "ns/op", + "baseline": 19.87, + "current": 20.2, + "delta": 0.3299999999999983, + "deltaPct": 1.6607951685958646, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16-20", + "metric": "ns/op", + "baseline": 4472, + "current": 4545, + "delta": 73, + "deltaPct": 1.6323792486583184, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "metric": "ns/op", + "baseline": 761.2, + "current": 773.6, + "delta": 12.399999999999977, + "deltaPct": 1.629006831318967, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportStateMicro-20", + "metric": "ns/op", + "baseline": 8.78, + "current": 8.638, + "delta": -0.14199999999999946, + "deltaPct": -1.6173120728929327, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer-20", + "metric": "ns/op", + "baseline": 9.008, + "current": 9.147, + "delta": 0.13900000000000112, + "deltaPct": 1.543072824156318, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "metric": "B/op", + "baseline": 33755, + "current": 34275, + "delta": 520, + "deltaPct": 1.5405125166641978, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterCreateElement", + "metric": "ns/op", + "baseline": 31740, + "current": 31259, + "delta": -481, + "deltaPct": -1.5154379332073094, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren-20", + "metric": "ns/op", + "baseline": 445.3, + "current": 438.8, + "delta": -6.5, + "deltaPct": -1.4596900965641142, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetValue", + "metric": "ns/op", + "baseline": 3434, + "current": 3391, + "delta": -43, + "deltaPct": -1.2521840419336052, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives", + "metric": "ns/op", + "baseline": 37.64, + "current": 37.17, + "delta": -0.46999999999999886, + "deltaPct": -1.2486716259298587, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32-20", + "metric": "ns/op", + "baseline": 10937, + "current": 11070, + "delta": 133, + "deltaPct": 1.2160555911127366, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkSnapshotSelect", + "metric": "ns/op", + "baseline": 259.2, + "current": 256.1, + "delta": -3.099999999999966, + "deltaPct": -1.1959876543209746, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventIsChecked", + "metric": "ns/op", + "baseline": 1907, + "current": 1885, + "delta": -22, + "deltaPct": -1.1536444677503932, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256", + "metric": "ns/op", + "baseline": 312.2, + "current": 308.7, + "delta": -3.5, + "deltaPct": -1.1210762331838566, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "metric": "B/op", + "baseline": 36035, + "current": 36437, + "delta": 402, + "deltaPct": 1.1155820729845982, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI-20", + "metric": "ns/op", + "baseline": 32.81, + "current": 33.17, + "delta": 0.35999999999999943, + "deltaPct": 1.0972264553489772, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender-20", + "metric": "B/op", + "baseline": 92, + "current": 93, + "delta": 1, + "deltaPct": 1.0869565217391304, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString", + "metric": "ns/op", + "baseline": 14.06, + "current": 13.91, + "delta": -0.15000000000000036, + "deltaPct": -1.0668563300142273, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt-20", + "metric": "ns/op", + "baseline": 1.548, + "current": 1.564, + "delta": 0.016000000000000014, + "deltaPct": 1.0335917312661507, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportState-20", + "metric": "ns/op", + "baseline": 16.7, + "current": 16.53, + "delta": -0.16999999999999815, + "deltaPct": -1.0179640718562764, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "metric": "ns/op", + "baseline": 759.6, + "current": 767, + "delta": 7.399999999999977, + "deltaPct": 0.9741969457609239, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGlobalInit", + "metric": "B/op", + "baseline": 1141, + "current": 1152, + "delta": 11, + "deltaPct": 0.9640666082383873, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps", + "metric": "B/op", + "baseline": 104, + "current": 103, + "delta": -1, + "deltaPct": -0.9615384615384616, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubRefetch-20", + "metric": "ns/op", + "baseline": 1.052, + "current": 1.042, + "delta": -0.010000000000000009, + "deltaPct": -0.950570342205324, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable-20", + "metric": "ns/op", + "baseline": 37.67, + "current": 38.02, + "delta": 0.3500000000000014, + "deltaPct": 0.9291213166976411, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom-20", + "metric": "ns/op", + "baseline": 13.02, + "current": 13.14, + "delta": 0.120000000000001, + "deltaPct": 0.9216589861751229, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps", + "metric": "B/op", + "baseline": 109, + "current": 110, + "delta": 1, + "deltaPct": 0.9174311926605505, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250", + "metric": "B/op", + "baseline": 229709, + "current": 231734, + "delta": 2025, + "deltaPct": 0.8815501351710208, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "metric": "B/op", + "baseline": 35791, + "current": 36093, + "delta": 302, + "deltaPct": 0.843787544354726, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable", + "metric": "ns/op", + "baseline": 172.4, + "current": 171, + "delta": -1.4000000000000057, + "deltaPct": -0.812064965197219, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250-20", + "metric": "ns/op", + "baseline": 237273, + "current": 238975, + "delta": 1702, + "deltaPct": 0.7173171831603259, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "metric": "B/op", + "baseline": 33430, + "current": 33194, + "delta": -236, + "deltaPct": -0.7059527370625187, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "metric": "B/op", + "baseline": 41535, + "current": 41758, + "delta": 223, + "deltaPct": 0.5368965932346214, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "metric": "B/op", + "baseline": 42768, + "current": 42613, + "delta": -155, + "deltaPct": -0.3624205013093902, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/hooks", + "benchmark": "BenchmarkHarnessStubMethodsMicro-20", + "metric": "ns/op", + "baseline": 0.1156, + "current": 0.116, + "delta": 0.00040000000000001146, + "deltaPct": 0.3460207612456847, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "metric": "B/op", + "baseline": 42595, + "current": 42466, + "delta": -129, + "deltaPct": -0.30285244747036033, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkCurrentNestedLayoutRoute", + "metric": "B/op", + "baseline": 12228, + "current": 12191, + "delta": -37, + "deltaPct": -0.3025842329080798, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting-20", + "metric": "ns/op", + "baseline": 29.82, + "current": 29.91, + "delta": 0.08999999999999986, + "deltaPct": 0.30181086519114636, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchRefetchUnavailable", + "metric": "ns/op", + "baseline": 15529536, + "current": 15573766, + "delta": 44230, + "deltaPct": 0.28481211544247037, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32-20", + "metric": "ns/op", + "baseline": 214.7, + "current": 215.2, + "delta": 0.5, + "deltaPct": 0.2328830926874709, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector-20", + "metric": "B/op", + "baseline": 7798, + "current": 7815, + "delta": 17, + "deltaPct": 0.21800461656835088, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "metric": "B/op", + "baseline": 37288, + "current": 37363, + "delta": 75, + "deltaPct": 0.201137095043982, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkTagDivWithCommonProps-20", + "metric": "ns/op", + "baseline": 753.9, + "current": 755.4, + "delta": 1.5, + "deltaPct": 0.19896538002387587, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "metric": "ns/op", + "baseline": 357.6, + "current": 358.3, + "delta": 0.6999999999999886, + "deltaPct": 0.19574944071588046, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookStateRerenderMicroWasm", + "metric": "B/op", + "baseline": 68085, + "current": 68208, + "delta": 123, + "deltaPct": 0.18065653227583167, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "metric": "B/op", + "baseline": 32851, + "current": 32907, + "delta": 56, + "deltaPct": 0.17046665246111228, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString-20", + "metric": "ns/op", + "baseline": 2.007, + "current": 2.004, + "delta": -0.0030000000000001137, + "deltaPct": -0.14947683109118653, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "metric": "B/op", + "baseline": 32926, + "current": 32970, + "delta": 44, + "deltaPct": 0.13363299520136063, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "metric": "B/op", + "baseline": 33724, + "current": 33685, + "delta": -39, + "deltaPct": -0.11564464476337326, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState", + "metric": "B/op", + "baseline": 33959, + "current": 33996, + "delta": 37, + "deltaPct": 0.10895491622250361, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250-20", + "metric": "B/op", + "baseline": 240468, + "current": 240726, + "delta": 258, + "deltaPct": 0.10729078297320226, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "metric": "B/op", + "baseline": 33277, + "current": 33312, + "delta": 35, + "deltaPct": 0.10517775039817293, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "metric": "B/op", + "baseline": 41519, + "current": 41556, + "delta": 37, + "deltaPct": 0.08911582648907729, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath", + "metric": "ns/op", + "baseline": 8.963, + "current": 8.956, + "delta": -0.006999999999999673, + "deltaPct": -0.07809885083119128, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter-20", + "metric": "ns/op", + "baseline": 14.1, + "current": 14.09, + "delta": -0.009999999999999787, + "deltaPct": -0.07092198581560133, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250", + "metric": "allocs/op", + "baseline": 1789, + "current": 1788, + "delta": -1, + "deltaPct": -0.05589714924538849, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector", + "metric": "B/op", + "baseline": 7796, + "current": 7792, + "delta": -4, + "deltaPct": -0.0513083632632119, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkLoggerScope-20", + "metric": "ns/op", + "baseline": 0.4965, + "current": 0.4963, + "delta": -0.00019999999999997797, + "deltaPct": -0.040281973816712585, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender", + "metric": "B/op", + "baseline": 33995, + "current": 34008, + "delta": 13, + "deltaPct": 0.03824091778202677, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState-20", + "metric": "B/op", + "baseline": 34162, + "current": 34169, + "delta": 7, + "deltaPct": 0.020490603594637315, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "metric": "B/op", + "baseline": 5542, + "current": 5541, + "delta": -1, + "deltaPct": -0.018044027426921686, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16-20", + "metric": "B/op", + "baseline": 5667, + "current": 5666, + "delta": -1, + "deltaPct": -0.01764602082230457, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkWriteHTTPError-20", + "metric": "B/op", + "baseline": 6443, + "current": 6444, + "delta": 1, + "deltaPct": 0.01552072016141549, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender-20", + "metric": "B/op", + "baseline": 34166, + "current": 34170, + "delta": 4, + "deltaPct": 0.011707545513083183, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "metric": "B/op", + "baseline": 35019, + "current": 35023, + "delta": 4, + "deltaPct": 0.011422370713041492, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback-20", + "metric": "B/op", + "baseline": 9208, + "current": 9209, + "delta": 1, + "deltaPct": 0.010860121633362294, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkCompareSnapshotsMicro-20", + "metric": "B/op", + "baseline": 11554, + "current": 11553, + "delta": -1, + "deltaPct": -0.008655011251514626, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse-20", + "metric": "B/op", + "baseline": 430818, + "current": 430804, + "delta": -14, + "deltaPct": -0.0032496320952235054, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "metric": "B/op", + "baseline": 35052, + "current": 35051, + "delta": -1, + "deltaPct": -0.0028529042565331505, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderToString-20", + "metric": "B/op", + "baseline": 36999, + "current": 37000, + "delta": 1, + "deltaPct": 0.0027027757506959647, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "metric": "B/op", + "baseline": 451299, + "current": 451294, + "delta": -5, + "deltaPct": -0.0011079129357698554, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse", + "metric": "B/op", + "baseline": 430012, + "current": 430011, + "delta": -1, + "deltaPct": -0.00023255164972140312, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkCompareSnapshotsMicro-20", + "metric": "allocs/op", + "baseline": 46, + "current": 46, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "metric": "allocs/op", + "baseline": 110, + "current": 110, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "metric": "allocs/op", + "baseline": 97, + "current": 97, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSnapshotNowMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSnapshotNowMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReport-20", + "metric": "B/op", + "baseline": 6494, + "current": 6494, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReport-20", + "metric": "allocs/op", + "baseline": 40, + "current": 40, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReportMicro-20", + "metric": "B/op", + "baseline": 6510, + "current": 6510, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReportMicro-20", + "metric": "allocs/op", + "baseline": 42, + "current": 42, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkWriteHTTPError-20", + "metric": "allocs/op", + "baseline": 41, + "current": 41, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkMergeDocumentMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkMergeDocumentMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderJSONLD-20", + "metric": "B/op", + "baseline": 9650, + "current": 9650, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderJSONLD-20", + "metric": "allocs/op", + "baseline": 45, + "current": 45, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderToString-20", + "metric": "allocs/op", + "baseline": 320, + "current": 320, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycle-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycle-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycleMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycleMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnabled-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnabled-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkCustomElementWithAttributesAndProperties-20", + "metric": "B/op", + "baseline": 912, + "current": 912, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkCustomElementWithAttributesAndProperties-20", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkDivNodeConstructionMicro-20", + "metric": "B/op", + "baseline": 872, + "current": 872, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkDivNodeConstructionMicro-20", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkTagDivWithCommonProps-20", + "metric": "B/op", + "baseline": 1064, + "current": 1064, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkTagDivWithCommonProps-20", + "metric": "allocs/op", + "baseline": 18, + "current": 18, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkClassNames-20", + "metric": "B/op", + "baseline": 336, + "current": 336, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkClassNames-20", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkTagWithMixedArgs-20", + "metric": "B/op", + "baseline": 4160, + "current": 4160, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkTagWithMixedArgs-20", + "metric": "allocs/op", + "baseline": 29, + "current": 29, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkBundleTranslate-20", + "metric": "B/op", + "baseline": 3176, + "current": 3176, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkBundleTranslate-20", + "metric": "allocs/op", + "baseline": 46, + "current": 46, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkNormalizeLocaleMicro-20", + "metric": "B/op", + "baseline": 244, + "current": 244, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkNormalizeLocaleMicro-20", + "metric": "allocs/op", + "baseline": 4, + "current": 4, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkBuild-20", + "metric": "B/op", + "baseline": 6141, + "current": 6141, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkBuild-20", + "metric": "allocs/op", + "baseline": 35, + "current": 35, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkReportFormatted-20", + "metric": "B/op", + "baseline": 1801, + "current": 1801, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkReportFormatted-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockSchedulerFlushAll-20", + "metric": "B/op", + "baseline": 816, + "current": 816, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockSchedulerFlushAll-20", + "metric": "allocs/op", + "baseline": 27, + "current": 27, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "metric": "B/op", + "baseline": 264, + "current": 264, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "metric": "B/op", + "baseline": 192, + "current": 192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8-20", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32-20", + "metric": "B/op", + "baseline": 21072, + "current": 21072, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32-20", + "metric": "allocs/op", + "baseline": 171, + "current": 171, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren-20", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren-20", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4-20", + "metric": "B/op", + "baseline": 744, + "current": 744, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4-20", + "metric": "allocs/op", + "baseline": 9, + "current": 9, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren-20", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren-20", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "metric": "allocs/op", + "baseline": 33, + "current": 33, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "metric": "allocs/op", + "baseline": 33, + "current": 33, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "metric": "allocs/op", + "baseline": 146, + "current": 146, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "metric": "allocs/op", + "baseline": 130, + "current": 130, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy-20", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate-20", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset-20", + "metric": "B/op", + "baseline": 444, + "current": 444, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset-20", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubGetter-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubGetter-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubInit-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubInit-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubRefetch-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubRefetch-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable-20", + "metric": "B/op", + "baseline": 90, + "current": 90, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps-20", + "metric": "B/op", + "baseline": 113, + "current": 113, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate-20", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset-20", + "metric": "B/op", + "baseline": 436, + "current": 436, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "metric": "allocs/op", + "baseline": 5759, + "current": 5759, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse-20", + "metric": "allocs/op", + "baseline": 6020, + "current": 6020, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse-20", + "metric": "B/op", + "baseline": 8535, + "current": 8535, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse-20", + "metric": "allocs/op", + "baseline": 70, + "current": 70, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback-20", + "metric": "allocs/op", + "baseline": 83, + "current": 83, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16-20", + "metric": "B/op", + "baseline": 5697, + "current": 5697, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16-20", + "metric": "allocs/op", + "baseline": 18, + "current": 18, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16-20", + "metric": "B/op", + "baseline": 5637, + "current": 5637, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16-20", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender-20", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector-20", + "metric": "allocs/op", + "baseline": 55, + "current": 55, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState-20", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo-20", + "metric": "B/op", + "baseline": 3114, + "current": 3114, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo-20", + "metric": "allocs/op", + "baseline": 20, + "current": 20, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate-20", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32-20", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState-20", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250-20", + "metric": "allocs/op", + "baseline": 1787, + "current": 1787, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender-20", + "metric": "B/op", + "baseline": 1120, + "current": 1120, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender-20", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4-20", + "metric": "B/op", + "baseline": 760, + "current": 760, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4-20", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct-20", + "metric": "B/op", + "baseline": 1137, + "current": 1137, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct-20", + "metric": "allocs/op", + "baseline": 29, + "current": 29, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString-20", + "metric": "B/op", + "baseline": 480, + "current": 480, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString-20", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsSmall-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsSmall-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkLoggerScope-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkLoggerScope-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkNewHostWithCapabilities-20", + "metric": "B/op", + "baseline": 592, + "current": 592, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkNewHostWithCapabilities-20", + "metric": "allocs/op", + "baseline": 4, + "current": 4, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkBuildTargetJSONBootstrap-20", + "metric": "B/op", + "baseline": 408, + "current": 408, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkBuildTargetJSONBootstrap-20", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePath-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePath-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePathMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePathMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlan-20", + "metric": "B/op", + "baseline": 2720, + "current": 2720, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlan-20", + "metric": "allocs/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "metric": "B/op", + "baseline": 2576, + "current": 2576, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "metric": "allocs/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkMarshalManifestJSON-20", + "metric": "B/op", + "baseline": 496, + "current": 496, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkMarshalManifestJSON-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro-20", + "metric": "B/op", + "baseline": 952, + "current": 952, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro-20", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/hooks", + "benchmark": "BenchmarkHarnessStubMethodsMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/hooks", + "benchmark": "BenchmarkHarnessStubMethodsMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/render", + "benchmark": "BenchmarkNewResourceControllerMicro-20", + "metric": "B/op", + "baseline": 240, + "current": 240, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/render", + "benchmark": "BenchmarkNewResourceControllerMicro-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/router", + "benchmark": "BenchmarkFixtureStubMethodsMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/router", + "benchmark": "BenchmarkFixtureStubMethodsMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/ssr", + "benchmark": "BenchmarkNormalizeStaticRoutePathMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/ssr", + "benchmark": "BenchmarkNormalizeStaticRoutePathMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapBinary-20", + "metric": "B/op", + "baseline": 402, + "current": 402, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapBinary-20", + "metric": "allocs/op", + "baseline": 4, + "current": 4, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapJSON-20", + "metric": "B/op", + "baseline": 3483, + "current": 3483, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapJSON-20", + "metric": "allocs/op", + "baseline": 43, + "current": 43, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "metric": "allocs/op", + "baseline": 81, + "current": 81, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderBootstrapReferenceScript-20", + "metric": "B/op", + "baseline": 1753, + "current": 1753, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderBootstrapReferenceScript-20", + "metric": "allocs/op", + "baseline": 19, + "current": 19, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringMicro-20", + "metric": "B/op", + "baseline": 64, + "current": 64, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringMicro-20", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringPublicSSRSurface-20", + "metric": "B/op", + "baseline": 4176, + "current": 4176, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringPublicSSRSurface-20", + "metric": "allocs/op", + "baseline": 55, + "current": 55, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "metric": "B/op", + "baseline": 1976, + "current": 1976, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "metric": "allocs/op", + "baseline": 42, + "current": 42, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "metric": "B/op", + "baseline": 2328, + "current": 2328, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "metric": "allocs/op", + "baseline": 54, + "current": 54, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportState-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportState-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportStateMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportStateMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkBuildMultipartFormData", + "metric": "B/op", + "baseline": 392, + "current": 392, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkBuildMultipartFormData", + "metric": "allocs/op", + "baseline": 35, + "current": 35, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkMergeResolvedMutation", + "metric": "B/op", + "baseline": 696, + "current": 696, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkMergeResolvedMutation", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationID", + "metric": "B/op", + "baseline": 40, + "current": 40, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationID", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationIDMicro", + "metric": "B/op", + "baseline": 63, + "current": 63, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationIDMicro", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkResolveMutationQueueOptions", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkResolveMutationQueueOptions", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "metric": "B/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionStringInvoke", + "metric": "B/op", + "baseline": 80, + "current": 80, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionStringInvoke", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterAppendChild", + "metric": "B/op", + "baseline": 344, + "current": 344, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterAppendChild", + "metric": "allocs/op", + "baseline": 33, + "current": 33, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterBatchAppend16", + "metric": "B/op", + "baseline": 1777, + "current": 1777, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterBatchAppend16", + "metric": "allocs/op", + "baseline": 171, + "current": 171, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterCreateElement", + "metric": "B/op", + "baseline": 248, + "current": 248, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterCreateElement", + "metric": "allocs/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterGetElementById", + "metric": "B/op", + "baseline": 240, + "current": 240, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterGetElementById", + "metric": "allocs/op", + "baseline": 23, + "current": 23, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelector", + "metric": "B/op", + "baseline": 240, + "current": 240, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelector", + "metric": "allocs/op", + "baseline": 23, + "current": 23, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "metric": "allocs/op", + "baseline": 27, + "current": 27, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetAttribute", + "metric": "B/op", + "baseline": 136, + "current": 136, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetAttribute", + "metric": "allocs/op", + "baseline": 13, + "current": 13, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetPropertyString", + "metric": "B/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetPropertyString", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "metric": "B/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "metric": "B/op", + "baseline": 80, + "current": 80, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMEventAdapterAddRemoveListener", + "metric": "B/op", + "baseline": 192, + "current": 192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMEventAdapterAddRemoveListener", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting", + "metric": "B/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers", + "metric": "B/op", + "baseline": 264, + "current": 264, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "metric": "B/op", + "baseline": 192, + "current": 192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32", + "metric": "B/op", + "baseline": 21072, + "current": 21072, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32", + "metric": "allocs/op", + "baseline": 171, + "current": 171, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4", + "metric": "B/op", + "baseline": 744, + "current": 744, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4", + "metric": "allocs/op", + "baseline": 9, + "current": 9, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "metric": "allocs/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "metric": "allocs/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "metric": "allocs/op", + "baseline": 146, + "current": 146, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "metric": "B/op", + "baseline": 41650, + "current": 41650, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "metric": "allocs/op", + "baseline": 130, + "current": 130, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKey", + "metric": "B/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKey", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKeyCode", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKeyCode", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetTarget", + "metric": "B/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetTarget", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetValue", + "metric": "B/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetValue", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventIsChecked", + "metric": "B/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventIsChecked", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGlobalInit", + "metric": "allocs/op", + "baseline": 9, + "current": 9, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset", + "metric": "B/op", + "baseline": 444, + "current": 444, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchInit", + "metric": "B/op", + "baseline": 680, + "current": 680, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchInit", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchRefetchUnavailable", + "metric": "B/op", + "baseline": 82, + "current": 82, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchRefetchUnavailable", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable", + "metric": "B/op", + "baseline": 84, + "current": 84, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateGlobalInit", + "metric": "B/op", + "baseline": 1024, + "current": 1024, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateGlobalInit", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset", + "metric": "B/op", + "baseline": 436, + "current": 436, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate", + "metric": "B/op", + "baseline": 450353, + "current": 450353, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate", + "metric": "allocs/op", + "baseline": 5757, + "current": 5757, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse", + "metric": "allocs/op", + "baseline": 6019, + "current": 6019, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse", + "metric": "B/op", + "baseline": 8520, + "current": 8520, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse", + "metric": "allocs/op", + "baseline": 70, + "current": 70, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback", + "metric": "B/op", + "baseline": 9192, + "current": 9192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback", + "metric": "allocs/op", + "baseline": 83, + "current": 83, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16", + "metric": "B/op", + "baseline": 5681, + "current": 5681, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16", + "metric": "allocs/op", + "baseline": 18, + "current": 18, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16", + "metric": "B/op", + "baseline": 5632, + "current": 5632, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16", + "metric": "B/op", + "baseline": 5656, + "current": 5656, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector", + "metric": "allocs/op", + "baseline": 55, + "current": 55, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo", + "metric": "B/op", + "baseline": 3112, + "current": 3112, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo", + "metric": "allocs/op", + "baseline": 20, + "current": 20, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTextShim", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTextShim", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender", + "metric": "B/op", + "baseline": 1120, + "current": 1120, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4", + "metric": "B/op", + "baseline": 760, + "current": 760, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct", + "metric": "B/op", + "baseline": 1136, + "current": 1136, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct", + "metric": "allocs/op", + "baseline": 29, + "current": 29, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString", + "metric": "B/op", + "baseline": 480, + "current": 480, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkLocalStorageGetItem", + "metric": "B/op", + "baseline": 96, + "current": 96, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkLocalStorageGetItem", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkModuleCall", + "metric": "B/op", + "baseline": 128, + "current": 128, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkModuleCall", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkCurrentNestedLayoutRoute", + "metric": "allocs/op", + "baseline": 685, + "current": 685, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkEvaluateNavigationNestedLayouts", + "metric": "B/op", + "baseline": 3552, + "current": 3552, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkEvaluateNavigationNestedLayouts", + "metric": "allocs/op", + "baseline": 41, + "current": 41, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkResolveRouteStackNestedLayout", + "metric": "B/op", + "baseline": 1808, + "current": 1808, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkResolveRouteStackNestedLayout", + "metric": "allocs/op", + "baseline": 15, + "current": 15, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro", + "metric": "B/op", + "baseline": 952, + "current": 952, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalSnapshotJSONMicro", + "metric": "B/op", + "baseline": 448, + "current": 448, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalSnapshotJSONMicro", + "metric": "allocs/op", + "baseline": 13, + "current": 13, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalUnmarshalSnapshotJSON", + "metric": "B/op", + "baseline": 1528, + "current": 1528, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalUnmarshalSnapshotJSON", + "metric": "allocs/op", + "baseline": 38, + "current": 38, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkSnapshotSelect", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkSnapshotSelect", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkUnmarshalSnapshotJSONMicro", + "metric": "B/op", + "baseline": 1656, + "current": 1656, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkUnmarshalSnapshotJSONMicro", + "metric": "allocs/op", + "baseline": 25, + "current": 25, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookCurrentMicroWasm", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookCurrentMicroWasm", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookStateRerenderMicroWasm", + "metric": "allocs/op", + "baseline": 35, + "current": 35, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneStringMapMicroWasm", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneStringMapMicroWasm", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneURLValuesMicroWasm", + "metric": "B/op", + "baseline": 48, + "current": 48, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneURLValuesMicroWasm", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + } + ] + } +} diff --git a/docs/benchmarks/reference.json b/docs/benchmarks/reference.json new file mode 100644 index 00000000..c9ddecc3 --- /dev/null +++ b/docs/benchmarks/reference.json @@ -0,0 +1,13313 @@ +{ + "ok": true, + "root": ".", + "generatedAt": "2026-03-25T15:17:41Z", + "goVersion": "go1.26.0", + "goos": "windows", + "goarch": "amd64", + "selectedLanes": [ + "native", + "wasm" + ], + "bench": ".", + "count": 1, + "packageParallelism": 1, + "reportPath": "./docs/benchmarks/reference.json", + "packageCount": 31, + "benchmarkCount": 249, + "failedPackages": 0, + "packages": [ + { + "lane": "native", + "package": "./devtools", + "workspace": "./devtools", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "samples": [ + { + "iterations": 19232, + "metrics": { + "B/op": 37288, + "allocs/op": 97, + "ns/op": 58799 + }, + "raw": "BenchmarkSanitizeBugCaptureBundleForSupport-20 \t 19232\t 58799 ns/op\t 37288 B/op\t 97 allocs/op" + } + ], + "averageMetrics": { + "B/op": 37288, + "allocs/op": 97, + "ns/op": 58799 + } + }, + { + "name": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "samples": [ + { + "iterations": 18753, + "metrics": { + "B/op": 41519, + "allocs/op": 110, + "ns/op": 60927 + }, + "raw": "BenchmarkExportSupportDiagnosticBundleJSON-20 \t 18753\t 60927 ns/op\t 41519 B/op\t 110 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41519, + "allocs/op": 110, + "ns/op": 60927 + } + }, + { + "name": "BenchmarkSnapshotNowMicro-20", + "samples": [ + { + "iterations": 44995893, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 28.14 + }, + "raw": "BenchmarkSnapshotNowMicro-20 \t44995893\t 28.14 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 28.14 + } + }, + { + "name": "BenchmarkCompareSnapshotsMicro-20", + "samples": [ + { + "iterations": 67214, + "metrics": { + "B/op": 11554, + "allocs/op": 46, + "ns/op": 17959 + }, + "raw": "BenchmarkCompareSnapshotsMicro-20 \t 67214\t 17959 ns/op\t 11554 B/op\t 46 allocs/op" + } + ], + "averageMetrics": { + "B/op": 11554, + "allocs/op": 46, + "ns/op": 17959 + } + } + ] + }, + { + "lane": "native", + "package": "./diagnostics", + "workspace": "./diagnostics", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkNewReport-20", + "samples": [ + { + "iterations": 111895, + "metrics": { + "B/op": 6494, + "allocs/op": 40, + "ns/op": 11260 + }, + "raw": "BenchmarkNewReport-20 \t 111895\t 11260 ns/op\t 6494 B/op\t 40 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6494, + "allocs/op": 40, + "ns/op": 11260 + } + }, + { + "name": "BenchmarkWriteHTTPError-20", + "samples": [ + { + "iterations": 276609, + "metrics": { + "B/op": 6443, + "allocs/op": 41, + "ns/op": 31498 + }, + "raw": "BenchmarkWriteHTTPError-20 \t 276609\t 31498 ns/op\t 6443 B/op\t 41 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6443, + "allocs/op": 41, + "ns/op": 31498 + } + }, + { + "name": "BenchmarkNewReportMicro-20", + "samples": [ + { + "iterations": 103356, + "metrics": { + "B/op": 6510, + "allocs/op": 42, + "ns/op": 12243 + }, + "raw": "BenchmarkNewReportMicro-20 \t 103356\t 12243 ns/op\t 6510 B/op\t 42 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6510, + "allocs/op": 42, + "ns/op": 12243 + } + } + ] + }, + { + "lane": "native", + "package": "./head", + "workspace": "./head", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkRenderToString-20", + "samples": [ + { + "iterations": 36481, + "metrics": { + "B/op": 36999, + "allocs/op": 320, + "ns/op": 36431 + }, + "raw": "BenchmarkRenderToString-20 \t 36481\t 36431 ns/op\t 36999 B/op\t 320 allocs/op" + } + ], + "averageMetrics": { + "B/op": 36999, + "allocs/op": 320, + "ns/op": 36431 + } + }, + { + "name": "BenchmarkRenderJSONLD-20", + "samples": [ + { + "iterations": 185588, + "metrics": { + "B/op": 9650, + "allocs/op": 45, + "ns/op": 10408 + }, + "raw": "BenchmarkRenderJSONLD-20 \t 185588\t 10408 ns/op\t 9650 B/op\t 45 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9650, + "allocs/op": 45, + "ns/op": 10408 + } + }, + { + "name": "BenchmarkMergeDocumentMicro-20", + "samples": [ + { + "iterations": 15111674, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 77.13 + }, + "raw": "BenchmarkMergeDocumentMicro-20 \t15111674\t 77.13 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 77.13 + } + } + ] + }, + { + "lane": "native", + "package": "./hotreload", + "workspace": "./hotreload", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkEnabled-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1996 + }, + "raw": "BenchmarkEnabled-20 \t1000000000\t 0.1996 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1996 + } + }, + { + "name": "BenchmarkEnableDisableCycle-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2259 + }, + "raw": "BenchmarkEnableDisableCycle-20 \t1000000000\t 0.2259 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2259 + } + }, + { + "name": "BenchmarkEnableDisableCycleMicro-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1102 + }, + "raw": "BenchmarkEnableDisableCycleMicro-20 \t1000000000\t 0.1102 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1102 + } + } + ] + }, + { + "lane": "native", + "package": "./html", + "workspace": "./html", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkTagDivWithCommonProps-20", + "samples": [ + { + "iterations": 1630996, + "metrics": { + "B/op": 1064, + "allocs/op": 18, + "ns/op": 753.9 + }, + "raw": "BenchmarkTagDivWithCommonProps-20 \t 1630996\t 753.9 ns/op\t 1064 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1064, + "allocs/op": 18, + "ns/op": 753.9 + } + }, + { + "name": "BenchmarkCustomElementWithAttributesAndProperties-20", + "samples": [ + { + "iterations": 1791192, + "metrics": { + "B/op": 912, + "allocs/op": 12, + "ns/op": 686.2 + }, + "raw": "BenchmarkCustomElementWithAttributesAndProperties-20 \t 1791192\t 686.2 ns/op\t 912 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 912, + "allocs/op": 12, + "ns/op": 686.2 + } + }, + { + "name": "BenchmarkDivNodeConstructionMicro-20", + "samples": [ + { + "iterations": 2034214, + "metrics": { + "B/op": 872, + "allocs/op": 10, + "ns/op": 659 + }, + "raw": "BenchmarkDivNodeConstructionMicro-20 \t 2034214\t 659.0 ns/op\t 872 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 872, + "allocs/op": 10, + "ns/op": 659 + } + } + ] + }, + { + "lane": "native", + "package": "./html/shorthand", + "workspace": "./html/shorthand", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkTagWithMixedArgs-20", + "samples": [ + { + "iterations": 611178, + "metrics": { + "B/op": 4160, + "allocs/op": 29, + "ns/op": 1789 + }, + "raw": "BenchmarkTagWithMixedArgs-20 \t 611178\t 1789 ns/op\t 4160 B/op\t 29 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4160, + "allocs/op": 29, + "ns/op": 1789 + } + }, + { + "name": "BenchmarkClassNames-20", + "samples": [ + { + "iterations": 3930164, + "metrics": { + "B/op": 336, + "allocs/op": 7, + "ns/op": 314.2 + }, + "raw": "BenchmarkClassNames-20 \t 3930164\t 314.2 ns/op\t 336 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 336, + "allocs/op": 7, + "ns/op": 314.2 + } + } + ] + }, + { + "lane": "native", + "package": "./i18n", + "workspace": "./i18n", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkBundleTranslate-20", + "samples": [ + { + "iterations": 339543, + "metrics": { + "B/op": 3176, + "allocs/op": 46, + "ns/op": 3338 + }, + "raw": "BenchmarkBundleTranslate-20 \t 339543\t 3338 ns/op\t 3176 B/op\t 46 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3176, + "allocs/op": 46, + "ns/op": 3338 + } + }, + { + "name": "BenchmarkNormalizeLocaleMicro-20", + "samples": [ + { + "iterations": 4149470, + "metrics": { + "B/op": 244, + "allocs/op": 4, + "ns/op": 323.7 + }, + "raw": "BenchmarkNormalizeLocaleMicro-20 \t 4149470\t 323.7 ns/op\t 244 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 244, + "allocs/op": 4, + "ns/op": 323.7 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "workspace": "./internal/diagnostics", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkBuild-20", + "samples": [ + { + "iterations": 119342, + "metrics": { + "B/op": 6141, + "allocs/op": 35, + "ns/op": 9609 + }, + "raw": "BenchmarkBuild-20 \t 119342\t 9609 ns/op\t 6141 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6141, + "allocs/op": 35, + "ns/op": 9609 + } + }, + { + "name": "BenchmarkReportFormatted-20", + "samples": [ + { + "iterations": 1705412, + "metrics": { + "B/op": 1801, + "allocs/op": 16, + "ns/op": 729.7 + }, + "raw": "BenchmarkReportFormatted-20 \t 1705412\t 729.7 ns/op\t 1801 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1801, + "allocs/op": 16, + "ns/op": 729.7 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "workspace": "./internal/platform/mockdom", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "samples": [ + { + "iterations": 1629745, + "metrics": { + "B/op": 1354, + "allocs/op": 7, + "ns/op": 759.6 + }, + "raw": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20 \t 1629745\t 759.6 ns/op\t 1354 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1354, + "allocs/op": 7, + "ns/op": 759.6 + } + }, + { + "name": "BenchmarkMockSchedulerFlushAll-20", + "samples": [ + { + "iterations": 711558, + "metrics": { + "B/op": 816, + "allocs/op": 27, + "ns/op": 1887 + }, + "raw": "BenchmarkMockSchedulerFlushAll-20 \t 711558\t 1887 ns/op\t 816 B/op\t 27 allocs/op" + } + ], + "averageMetrics": { + "B/op": 816, + "allocs/op": 27, + "ns/op": 1887 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/runtime", + "workspace": "./internal/runtime", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 75, + "benchmarks": [ + { + "name": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "samples": [ + { + "iterations": 64696, + "metrics": { + "B/op": 42768, + "allocs/op": 146, + "ns/op": 18650 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20 \t 64696\t 18650 ns/op\t 42768 B/op\t 146 allocs/op" + } + ], + "averageMetrics": { + "B/op": 42768, + "allocs/op": 146, + "ns/op": 18650 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "samples": [ + { + "iterations": 165409, + "metrics": { + "B/op": 33430, + "allocs/op": 8, + "ns/op": 6646 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20 \t 165409\t 6646 ns/op\t 33430 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33430, + "allocs/op": 8, + "ns/op": 6646 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "samples": [ + { + "iterations": 66084, + "metrics": { + "B/op": 42595, + "allocs/op": 130, + "ns/op": 26564 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20 \t 66084\t 26564 ns/op\t 42595 B/op\t 130 allocs/op" + } + ], + "averageMetrics": { + "B/op": 42595, + "allocs/op": 130, + "ns/op": 26564 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "samples": [ + { + "iterations": 127540, + "metrics": { + "B/op": 33724, + "allocs/op": 11, + "ns/op": 11512 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20 \t 127540\t 11512 ns/op\t 33724 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33724, + "allocs/op": 11, + "ns/op": 11512 + } + }, + { + "name": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "samples": [ + { + "iterations": 66469, + "metrics": { + "B/op": 33755, + "allocs/op": 17, + "ns/op": 21123 + }, + "raw": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20 \t 66469\t 21123 ns/op\t 33755 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33755, + "allocs/op": 17, + "ns/op": 21123 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "samples": [ + { + "iterations": 23786, + "metrics": { + "B/op": 36035, + "allocs/op": 33, + "ns/op": 45690 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20 \t 23786\t 45690 ns/op\t 36035 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 36035, + "allocs/op": 33, + "ns/op": 45690 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "samples": [ + { + "iterations": 24909, + "metrics": { + "B/op": 35791, + "allocs/op": 33, + "ns/op": 46576 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20 \t 24909\t 46576 ns/op\t 35791 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 35791, + "allocs/op": 33, + "ns/op": 46576 + } + }, + { + "name": "BenchmarkIsNilableTypeCachedPointer-20", + "samples": [ + { + "iterations": 126692425, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.008 + }, + "raw": "BenchmarkIsNilableTypeCachedPointer-20 \t126692425\t 9.008 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.008 + } + }, + { + "name": "BenchmarkFastEqualInt-20", + "samples": [ + { + "iterations": 772976234, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.548 + }, + "raw": "BenchmarkFastEqualInt-20 \t772976234\t 1.548 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.548 + } + }, + { + "name": "BenchmarkFastEqualString-20", + "samples": [ + { + "iterations": 600697408, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.007 + }, + "raw": "BenchmarkFastEqualString-20 \t600697408\t 2.007 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.007 + } + }, + { + "name": "BenchmarkAreDepsEqual3Primitives-20", + "samples": [ + { + "iterations": 143947614, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.448 + }, + "raw": "BenchmarkAreDepsEqual3Primitives-20 \t143947614\t 8.448 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.448 + } + }, + { + "name": "BenchmarkGoUseStateIntDirectUpdate-20", + "samples": [ + { + "iterations": 2712207, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 480.9 + }, + "raw": "BenchmarkGoUseStateIntDirectUpdate-20 \t 2712207\t 480.9 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 480.9 + } + }, + { + "name": "BenchmarkGoUseStatePointerNilReset-20", + "samples": [ + { + "iterations": 3013507, + "metrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 441.9 + }, + "raw": "BenchmarkGoUseStatePointerNilReset-20 \t 3013507\t 441.9 ns/op\t 436 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 441.9 + } + }, + { + "name": "BenchmarkGoUseMemoSameDeps-20", + "samples": [ + { + "iterations": 16522347, + "metrics": { + "B/op": 113, + "allocs/op": 1, + "ns/op": 61.01 + }, + "raw": "BenchmarkGoUseMemoSameDeps-20 \t16522347\t 61.01 ns/op\t 113 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 113, + "allocs/op": 1, + "ns/op": 61.01 + } + }, + { + "name": "BenchmarkGoUseCallbackSameDeps-20", + "samples": [ + { + "iterations": 29672856, + "metrics": { + "B/op": 101, + "allocs/op": 1, + "ns/op": 51.47 + }, + "raw": "BenchmarkGoUseCallbackSameDeps-20 \t29672856\t 51.47 ns/op\t 101 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 101, + "allocs/op": 1, + "ns/op": 51.47 + } + }, + { + "name": "BenchmarkGoUseRefStable-20", + "samples": [ + { + "iterations": 40740802, + "metrics": { + "B/op": 96, + "allocs/op": 0, + "ns/op": 37.67 + }, + "raw": "BenchmarkGoUseRefStable-20 \t40740802\t 37.67 ns/op\t 96 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 96, + "allocs/op": 0, + "ns/op": 37.67 + } + }, + { + "name": "BenchmarkGoUseIdStable-20", + "samples": [ + { + "iterations": 28024614, + "metrics": { + "B/op": 90, + "allocs/op": 0, + "ns/op": 44 + }, + "raw": "BenchmarkGoUseIdStable-20 \t28024614\t 44.00 ns/op\t 90 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 90, + "allocs/op": 0, + "ns/op": 44 + } + }, + { + "name": "BenchmarkGoUseFuncWrap-20", + "samples": [ + { + "iterations": 17340288, + "metrics": { + "B/op": 133, + "allocs/op": 2, + "ns/op": 73.7 + }, + "raw": "BenchmarkGoUseFuncWrap-20 \t17340288\t 73.70 ns/op\t 133 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 133, + "allocs/op": 2, + "ns/op": 73.7 + } + }, + { + "name": "BenchmarkGoUseEffectSameDeps-20", + "samples": [ + { + "iterations": 29563743, + "metrics": { + "B/op": 101, + "allocs/op": 1, + "ns/op": 42.1 + }, + "raw": "BenchmarkGoUseEffectSameDeps-20 \t29563743\t 42.10 ns/op\t 101 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 101, + "allocs/op": 1, + "ns/op": 42.1 + } + }, + { + "name": "BenchmarkGoUseFetchStubInit-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.114 + }, + "raw": "BenchmarkGoUseFetchStubInit-20 \t1000000000\t 0.1140 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.114 + } + }, + { + "name": "BenchmarkGoUseFetchStubGetter-20", + "samples": [ + { + "iterations": 847193178, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.424 + }, + "raw": "BenchmarkGoUseFetchStubGetter-20 \t847193178\t 1.424 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.424 + } + }, + { + "name": "BenchmarkGoUseFetchStubRefetch-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.052 + }, + "raw": "BenchmarkGoUseFetchStubRefetch-20 \t1000000000\t 1.052 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.052 + } + }, + { + "name": "BenchmarkDivWithTextChildren-20", + "samples": [ + { + "iterations": 2988364, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 445.3 + }, + "raw": "BenchmarkDivWithTextChildren-20 \t 2988364\t 445.3 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 445.3 + } + }, + { + "name": "BenchmarkDivWithComponents4-20", + "samples": [ + { + "iterations": 2400093, + "metrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 588.9 + }, + "raw": "BenchmarkDivWithComponents4-20 \t 2400093\t 588.9 ns/op\t 744 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 588.9 + } + }, + { + "name": "BenchmarkWithComponentsGeneric4-20", + "samples": [ + { + "iterations": 1975724, + "metrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 531.4 + }, + "raw": "BenchmarkWithComponentsGeneric4-20 \t 1975724\t 531.4 ns/op\t 760 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 531.4 + } + }, + { + "name": "BenchmarkHydrateSimpleReuse-20", + "samples": [ + { + "iterations": 149954, + "metrics": { + "B/op": 8535, + "allocs/op": 70, + "ns/op": 7738 + }, + "raw": "BenchmarkHydrateSimpleReuse-20 \t 149954\t 7738 ns/op\t 8535 B/op\t 70 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8535, + "allocs/op": 70, + "ns/op": 7738 + } + }, + { + "name": "BenchmarkHydrateTagMismatchFallback-20", + "samples": [ + { + "iterations": 162042, + "metrics": { + "B/op": 9208, + "allocs/op": 83, + "ns/op": 8880 + }, + "raw": "BenchmarkHydrateTagMismatchFallback-20 \t 162042\t 8880 ns/op\t 9208 B/op\t 83 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9208, + "allocs/op": 83, + "ns/op": 8880 + } + }, + { + "name": "BenchmarkHydrateMediumTreeReuse-20", + "samples": [ + { + "iterations": 3580, + "metrics": { + "B/op": 430818, + "allocs/op": 6020, + "ns/op": 396136 + }, + "raw": "BenchmarkHydrateMediumTreeReuse-20 \t 3580\t 396136 ns/op\t 430818 B/op\t 6020 allocs/op" + } + ], + "averageMetrics": { + "B/op": 430818, + "allocs/op": 6020, + "ns/op": 396136 + } + }, + { + "name": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "samples": [ + { + "iterations": 3339, + "metrics": { + "B/op": 451299, + "allocs/op": 5759, + "ns/op": 483564 + }, + "raw": "BenchmarkHydrateMediumTreeFirstUpdate-20 \t 3339\t 483564 ns/op\t 451299 B/op\t 5759 allocs/op" + } + ], + "averageMetrics": { + "B/op": 451299, + "allocs/op": 5759, + "ns/op": 483564 + } + }, + { + "name": "BenchmarkDOMNodeInterfaceEquals-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.114 + }, + "raw": "BenchmarkDOMNodeInterfaceEquals-20 \t1000000000\t 0.1140 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.114 + } + }, + { + "name": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "samples": [ + { + "iterations": 54603532, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 21.98 + }, + "raw": "BenchmarkDOMAdapterInterfaceCreateElement-20 \t54603532\t 21.98 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 21.98 + } + }, + { + "name": "BenchmarkSchedulerInterfaceSetTimeout-20", + "samples": [ + { + "iterations": 68979392, + "metrics": { + "B/op": 45, + "allocs/op": 0, + "ns/op": 14.72 + }, + "raw": "BenchmarkSchedulerInterfaceSetTimeout-20 \t68979392\t 14.72 ns/op\t 45 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 45, + "allocs/op": 0, + "ns/op": 14.72 + } + }, + { + "name": "BenchmarkRuntimeLayoutBaselines-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.1144 + }, + "raw": "BenchmarkRuntimeLayoutBaselines-20 \t1000000000\t 0.1144 ns/op\t 64.00 element-bytes\t 40.00 fetchstate-bytes\t 8.000 fiber-align\t 344.0 fiber-bytes\t 8.000 hooks-align\t 424.0 hooks-bytes\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.1144 + } + }, + { + "name": "BenchmarkFiberHotFieldScan256-20", + "samples": [ + { + "iterations": 6429640, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 190.2 + }, + "raw": "BenchmarkFiberHotFieldScan256-20 \t 6429640\t 190.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 190.2 + } + }, + { + "name": "BenchmarkFiberSiblingWalk256-20", + "samples": [ + { + "iterations": 4058598, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 294.8 + }, + "raw": "BenchmarkFiberSiblingWalk256-20 \t 4058598\t 294.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 294.8 + } + }, + { + "name": "BenchmarkHooksIndexResetHotPath-20", + "samples": [ + { + "iterations": 168438214, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.159 + }, + "raw": "BenchmarkHooksIndexResetHotPath-20 \t168438214\t 7.159 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.159 + } + }, + { + "name": "BenchmarkRenderPortalToSelector-20", + "samples": [ + { + "iterations": 215884, + "metrics": { + "B/op": 7798, + "allocs/op": 55, + "ns/op": 4993 + }, + "raw": "BenchmarkRenderPortalToSelector-20 \t 215884\t 4993 ns/op\t 7798 B/op\t 55 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7798, + "allocs/op": 55, + "ns/op": 4993 + } + }, + { + "name": "BenchmarkCreateElementHostWithTextChildren-20", + "samples": [ + { + "iterations": 3413092, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 331.4 + }, + "raw": "BenchmarkCreateElementHostWithTextChildren-20 \t 3413092\t 331.4 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 331.4 + } + }, + { + "name": "BenchmarkPropsEqualChildrenSamePointer-20", + "samples": [ + { + "iterations": 23924254, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 49.24 + }, + "raw": "BenchmarkPropsEqualChildrenSamePointer-20 \t23924254\t 49.24 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 49.24 + } + }, + { + "name": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "samples": [ + { + "iterations": 28213917, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 43.25 + }, + "raw": "BenchmarkPropsEqualChildrenDifferentPointer-20 \t28213917\t 43.25 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 43.25 + } + }, + { + "name": "BenchmarkReconcileChildrenStableList16-20", + "samples": [ + { + "iterations": 342094, + "metrics": { + "B/op": 5637, + "allocs/op": 16, + "ns/op": 3977 + }, + "raw": "BenchmarkReconcileChildrenStableList16-20 \t 342094\t 3977 ns/op\t 5637 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5637, + "allocs/op": 16, + "ns/op": 3977 + } + }, + { + "name": "BenchmarkReconcileChildrenWithFragments16-20", + "samples": [ + { + "iterations": 343862, + "metrics": { + "B/op": 5667, + "allocs/op": 17, + "ns/op": 4472 + }, + "raw": "BenchmarkReconcileChildrenWithFragments16-20 \t 343862\t 4472 ns/op\t 5667 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5667, + "allocs/op": 17, + "ns/op": 4472 + } + }, + { + "name": "BenchmarkReconcileChildrenKeyedStableList16-20", + "samples": [ + { + "iterations": 203918, + "metrics": { + "B/op": 5697, + "allocs/op": 18, + "ns/op": 5314 + }, + "raw": "BenchmarkReconcileChildrenKeyedStableList16-20 \t 203918\t 5314 ns/op\t 5697 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5697, + "allocs/op": 18, + "ns/op": 5314 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "samples": [ + { + "iterations": 1415845, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 877 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20 \t 1415845\t 877.0 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 877 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "samples": [ + { + "iterations": 1333074, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 988.9 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20 \t 1333074\t 988.9 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 988.9 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesInitialRender-20", + "samples": [ + { + "iterations": 2093124, + "metrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 640.5 + }, + "raw": "BenchmarkUpdateDomPropertiesInitialRender-20 \t 2093124\t 640.5 ns/op\t 1120 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 640.5 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesSteadyState-20", + "samples": [ + { + "iterations": 3060146, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 399.2 + }, + "raw": "BenchmarkUpdateDomPropertiesSteadyState-20 \t 3060146\t 399.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 399.2 + } + }, + { + "name": "BenchmarkCommitDeletionDomlessSubtree32-20", + "samples": [ + { + "iterations": 114061, + "metrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 10937 + }, + "raw": "BenchmarkCommitDeletionDomlessSubtree32-20 \t 114061\t 10937 ns/op\t 21072 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 10937 + } + }, + { + "name": "BenchmarkCommitWorkPlacementChain16-20", + "samples": [ + { + "iterations": 3433309, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 369.7 + }, + "raw": "BenchmarkCommitWorkPlacementChain16-20 \t 3433309\t 369.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 369.7 + } + }, + { + "name": "BenchmarkRunEffectsChain16-20", + "samples": [ + { + "iterations": 5297146, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 235.3 + }, + "raw": "BenchmarkRunEffectsChain16-20 \t 5297146\t 235.3 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 235.3 + } + }, + { + "name": "BenchmarkGetGlobalRuntimeLazy-20", + "samples": [ + { + "iterations": 2818422, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 468.9 + }, + "raw": "BenchmarkGetGlobalRuntimeLazy-20 \t 2818422\t 468.9 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 468.9 + } + }, + { + "name": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "samples": [ + { + "iterations": 2729998, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 451.8 + }, + "raw": "BenchmarkInitGlobalRuntimeAfterLazyGet-20 \t 2729998\t 451.8 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 451.8 + } + }, + { + "name": "BenchmarkRenderTo-20", + "samples": [ + { + "iterations": 665004, + "metrics": { + "B/op": 3114, + "allocs/op": 20, + "ns/op": 1751 + }, + "raw": "BenchmarkRenderTo-20 \t 665004\t 1751 ns/op\t 3114 B/op\t 20 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3114, + "allocs/op": 20, + "ns/op": 1751 + } + }, + { + "name": "BenchmarkScheduleUpdate-20", + "samples": [ + { + "iterations": 6856840, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 170.4 + }, + "raw": "BenchmarkScheduleUpdate-20 \t 6856840\t 170.4 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 170.4 + } + }, + { + "name": "BenchmarkScheduleUpdateSteadyState-20", + "samples": [ + { + "iterations": 8387748, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 176.9 + }, + "raw": "BenchmarkScheduleUpdateSteadyState-20 \t 8387748\t 176.9 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 176.9 + } + }, + { + "name": "BenchmarkScheduleUpdateForFiberDepth32-20", + "samples": [ + { + "iterations": 5926612, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 214.7 + }, + "raw": "BenchmarkScheduleUpdateForFiberDepth32-20 \t 5926612\t 214.7 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 214.7 + } + }, + { + "name": "BenchmarkRender-20", + "samples": [ + { + "iterations": 149214, + "metrics": { + "B/op": 34166, + "allocs/op": 11, + "ns/op": 7882 + }, + "raw": "BenchmarkRender-20 \t 149214\t 7882 ns/op\t 34166 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34166, + "allocs/op": 11, + "ns/op": 7882 + } + }, + { + "name": "BenchmarkRenderSteadyState-20", + "samples": [ + { + "iterations": 141872, + "metrics": { + "B/op": 34162, + "allocs/op": 11, + "ns/op": 9748 + }, + "raw": "BenchmarkRenderSteadyState-20 \t 141872\t 9748 ns/op\t 34162 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34162, + "allocs/op": 11, + "ns/op": 9748 + } + }, + { + "name": "BenchmarkEnqueueUI-20", + "samples": [ + { + "iterations": 38273116, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 32.81 + }, + "raw": "BenchmarkEnqueueUI-20 \t38273116\t 32.81 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 32.81 + } + }, + { + "name": "BenchmarkProcessUIQueueBatch64-20", + "samples": [ + { + "iterations": 652386, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1869 + }, + "raw": "BenchmarkProcessUIQueueBatch64-20 \t 652386\t 1869 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1869 + } + }, + { + "name": "BenchmarkTransitionListRefresh250-20", + "samples": [ + { + "iterations": 5049, + "metrics": { + "B/op": 240468, + "allocs/op": 1787, + "ns/op": 237273 + }, + "raw": "BenchmarkTransitionListRefresh250-20 \t 5049\t 237273 ns/op\t 240468 B/op\t 1787 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240468, + "allocs/op": 1787, + "ns/op": 237273 + } + }, + { + "name": "BenchmarkAtomRegistryInitAtomExisting-20", + "samples": [ + { + "iterations": 39396446, + "metrics": { + "B/op": 8, + "allocs/op": 0, + "ns/op": 29.82 + }, + "raw": "BenchmarkAtomRegistryInitAtomExisting-20 \t39396446\t 29.82 ns/op\t 8 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 0, + "ns/op": 29.82 + } + }, + { + "name": "BenchmarkAtomRegistryGetAtom-20", + "samples": [ + { + "iterations": 87284787, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.02 + }, + "raw": "BenchmarkAtomRegistryGetAtom-20 \t87284787\t 13.02 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.02 + } + }, + { + "name": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "samples": [ + { + "iterations": 6687814, + "metrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 174.8 + }, + "raw": "BenchmarkAtomRegistrySubscribeUnsubscribe-20 \t 6687814\t 174.8 ns/op\t 192 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 174.8 + } + }, + { + "name": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "samples": [ + { + "iterations": 3605845, + "metrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 357.6 + }, + "raw": "BenchmarkAtomRegistrySetAtom32Subscribers-20 \t 3605845\t 357.6 ns/op\t 264 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 357.6 + } + }, + { + "name": "BenchmarkGoUseAtomIntUpdate-20", + "samples": [ + { + "iterations": 3304306, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 379.6 + }, + "raw": "BenchmarkGoUseAtomIntUpdate-20 \t 3304306\t 379.6 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 379.6 + } + }, + { + "name": "BenchmarkGoUseAtomPointerNilReset-20", + "samples": [ + { + "iterations": 3290445, + "metrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 334 + }, + "raw": "BenchmarkGoUseAtomPointerNilReset-20 \t 3290445\t 334.0 ns/op\t 444 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 334 + } + }, + { + "name": "BenchmarkGoUseAtomGetter-20", + "samples": [ + { + "iterations": 87334336, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.1 + }, + "raw": "BenchmarkGoUseAtomGetter-20 \t87334336\t 14.10 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.1 + } + }, + { + "name": "BenchmarkGoUseAtomStableRerender-20", + "samples": [ + { + "iterations": 21737554, + "metrics": { + "B/op": 92, + "allocs/op": 0, + "ns/op": 58.29 + }, + "raw": "BenchmarkGoUseAtomStableRerender-20 \t21737554\t 58.29 ns/op\t 92 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 92, + "allocs/op": 0, + "ns/op": 58.29 + } + }, + { + "name": "BenchmarkCleanupAtomSubscriptions8-20", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1197 + }, + "raw": "BenchmarkCleanupAtomSubscriptions8-20 \t 1000000\t 1197 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1197 + } + }, + { + "name": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1179 + }, + "raw": "BenchmarkAtomRegistryUnsubscribeMany8-20 \t 1000000\t 1179 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1179 + } + }, + { + "name": "BenchmarkFiberAllocation-20", + "samples": [ + { + "iterations": 100000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.4 + }, + "raw": "BenchmarkFiberAllocation-20 \t100000000\t 11.40 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.4 + } + }, + { + "name": "BenchmarkElementLiteralCreation-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1125 + }, + "raw": "BenchmarkElementLiteralCreation-20 \t1000000000\t 0.1125 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1125 + } + }, + { + "name": "BenchmarkHooksPackedStateRead-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1112 + }, + "raw": "BenchmarkHooksPackedStateRead-20 \t1000000000\t 0.1112 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1112 + } + }, + { + "name": "BenchmarkFetchStateCopy-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1118 + }, + "raw": "BenchmarkFetchStateCopy-20 \t1000000000\t 0.1118 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1118 + } + } + ] + }, + { + "lane": "native", + "package": "./interop", + "workspace": "./interop", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkDecodeMapToStruct-20", + "samples": [ + { + "iterations": 602314, + "metrics": { + "B/op": 1137, + "allocs/op": 29, + "ns/op": 1980 + }, + "raw": "BenchmarkDecodeMapToStruct-20 \t 602314\t 1980 ns/op\t 1137 B/op\t 29 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1137, + "allocs/op": 29, + "ns/op": 1980 + } + }, + { + "name": "BenchmarkInteropErrorString-20", + "samples": [ + { + "iterations": 7624062, + "metrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 159.3 + }, + "raw": "BenchmarkInteropErrorString-20 \t 7624062\t 159.3 ns/op\t 480 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 159.3 + } + }, + { + "name": "BenchmarkClientCanExchangeMicro-20", + "samples": [ + { + "iterations": 17278119, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 73.87 + }, + "raw": "BenchmarkClientCanExchangeMicro-20 \t17278119\t 73.87 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 73.87 + } + } + ] + }, + { + "lane": "native", + "package": "./logging", + "workspace": "./logging", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkCloneFieldsSmall-20", + "samples": [ + { + "iterations": 16212666, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 71.79 + }, + "raw": "BenchmarkCloneFieldsSmall-20 \t16212666\t 71.79 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 71.79 + } + }, + { + "name": "BenchmarkLoggerScope-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.4965 + }, + "raw": "BenchmarkLoggerScope-20 \t1000000000\t 0.4965 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.4965 + } + }, + { + "name": "BenchmarkCloneFieldsMicro-20", + "samples": [ + { + "iterations": 20161188, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 59.38 + }, + "raw": "BenchmarkCloneFieldsMicro-20 \t20161188\t 59.38 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 59.38 + } + } + ] + }, + { + "lane": "native", + "package": "./plugin", + "workspace": "./plugin", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkEvaluateRouteMicro-20", + "samples": [ + { + "iterations": 59199328, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.87 + }, + "raw": "BenchmarkEvaluateRouteMicro-20 \t59199328\t 19.87 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.87 + } + }, + { + "name": "BenchmarkNewHostWithCapabilities-20", + "samples": [ + { + "iterations": 6790195, + "metrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 174.1 + }, + "raw": "BenchmarkNewHostWithCapabilities-20 \t 6790195\t 174.1 ns/op\t 592 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 174.1 + } + }, + { + "name": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "samples": [ + { + "iterations": 57384692, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 20.61 + }, + "raw": "BenchmarkEvaluateRouteWithSingleAllowGuard-20 \t57384692\t 20.61 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 20.61 + } + } + ] + }, + { + "lane": "native", + "package": "./prerender", + "workspace": "./prerender", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkNormalizeRoutePath-20", + "samples": [ + { + "iterations": 304426281, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.924 + }, + "raw": "BenchmarkNormalizeRoutePath-20 \t304426281\t 3.924 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.924 + } + }, + { + "name": "BenchmarkBuildTargetJSONBootstrap-20", + "samples": [ + { + "iterations": 3074263, + "metrics": { + "B/op": 408, + "allocs/op": 12, + "ns/op": 395.8 + }, + "raw": "BenchmarkBuildTargetJSONBootstrap-20 \t 3074263\t 395.8 ns/op\t 408 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 408, + "allocs/op": 12, + "ns/op": 395.8 + } + }, + { + "name": "BenchmarkNormalizeRoutePathMicro-20", + "samples": [ + { + "iterations": 272749464, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.418 + }, + "raw": "BenchmarkNormalizeRoutePathMicro-20 \t272749464\t 4.418 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.418 + } + } + ] + }, + { + "lane": "native", + "package": "./pwa", + "workspace": "./pwa", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "samples": [ + { + "iterations": 687582, + "metrics": { + "B/op": 2576, + "allocs/op": 24, + "ns/op": 1774 + }, + "raw": "BenchmarkBuildServiceWorkerAssetPlanMicro-20 \t 687582\t 1774 ns/op\t 2576 B/op\t 24 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2576, + "allocs/op": 24, + "ns/op": 1774 + } + }, + { + "name": "BenchmarkMarshalManifestJSON-20", + "samples": [ + { + "iterations": 2093698, + "metrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 700.4 + }, + "raw": "BenchmarkMarshalManifestJSON-20 \t 2093698\t 700.4 ns/op\t 496 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 700.4 + } + }, + { + "name": "BenchmarkBuildServiceWorkerAssetPlan-20", + "samples": [ + { + "iterations": 682286, + "metrics": { + "B/op": 2720, + "allocs/op": 24, + "ns/op": 2288 + }, + "raw": "BenchmarkBuildServiceWorkerAssetPlan-20 \t 682286\t 2288 ns/op\t 2720 B/op\t 24 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2720, + "allocs/op": 24, + "ns/op": 2288 + } + } + ] + }, + { + "lane": "native", + "package": "./router", + "workspace": "./router", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkRouteContractMustHrefForMicro-20", + "samples": [ + { + "iterations": 1937853, + "metrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 603.3 + }, + "raw": "BenchmarkRouteContractMustHrefForMicro-20 \t 1937853\t 603.3 ns/op\t 952 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 603.3 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/hooks", + "workspace": "./testkit/hooks", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkHarnessStubMethodsMicro-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1156 + }, + "raw": "BenchmarkHarnessStubMethodsMicro-20 \t1000000000\t 0.1156 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1156 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/render", + "workspace": "./testkit/render", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkNewResourceControllerMicro-20", + "samples": [ + { + "iterations": 26609662, + "metrics": { + "B/op": 240, + "allocs/op": 1, + "ns/op": 46.08 + }, + "raw": "BenchmarkNewResourceControllerMicro-20 \t26609662\t 46.08 ns/op\t 240 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 1, + "ns/op": 46.08 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/router", + "workspace": "./testkit/router", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkFixtureStubMethodsMicro-20", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1199 + }, + "raw": "BenchmarkFixtureStubMethodsMicro-20 \t1000000000\t 0.1199 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.1199 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/ssr", + "workspace": "./testkit/ssr", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkNormalizeStaticRoutePathMicro-20", + "samples": [ + { + "iterations": 245267962, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 5.447 + }, + "raw": "BenchmarkNormalizeStaticRoutePathMicro-20 \t245267962\t 5.447 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 5.447 + } + } + ] + }, + { + "lane": "native", + "package": "./ui", + "workspace": "./ui", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 8, + "benchmarks": [ + { + "name": "BenchmarkRenderToStringMicro-20", + "samples": [ + { + "iterations": 7642722, + "metrics": { + "B/op": 64, + "allocs/op": 3, + "ns/op": 144.4 + }, + "raw": "BenchmarkRenderToStringMicro-20 \t 7642722\t 144.4 ns/op\t 64 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 64, + "allocs/op": 3, + "ns/op": 144.4 + } + }, + { + "name": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "samples": [ + { + "iterations": 131983, + "metrics": { + "B/op": 5542, + "allocs/op": 81, + "ns/op": 10071 + }, + "raw": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20 \t 131983\t 10071 ns/op\t 5542 B/op\t 81 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5542, + "allocs/op": 81, + "ns/op": 10071 + } + }, + { + "name": "BenchmarkRenderToStringPublicSSRSurface-20", + "samples": [ + { + "iterations": 209479, + "metrics": { + "B/op": 4176, + "allocs/op": 55, + "ns/op": 4929 + }, + "raw": "BenchmarkRenderToStringPublicSSRSurface-20 \t 209479\t 4929 ns/op\t 4176 B/op\t 55 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4176, + "allocs/op": 55, + "ns/op": 4929 + } + }, + { + "name": "BenchmarkMarshalSSRBootstrapJSON-20", + "samples": [ + { + "iterations": 215768, + "metrics": { + "B/op": 3483, + "allocs/op": 43, + "ns/op": 5019 + }, + "raw": "BenchmarkMarshalSSRBootstrapJSON-20 \t 215768\t 5019 ns/op\t 3483 B/op\t 43 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3483, + "allocs/op": 43, + "ns/op": 5019 + } + }, + { + "name": "BenchmarkMarshalSSRBootstrapBinary-20", + "samples": [ + { + "iterations": 943928, + "metrics": { + "B/op": 402, + "allocs/op": 4, + "ns/op": 1227 + }, + "raw": "BenchmarkMarshalSSRBootstrapBinary-20 \t 943928\t 1227 ns/op\t 402 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 402, + "allocs/op": 4, + "ns/op": 1227 + } + }, + { + "name": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "samples": [ + { + "iterations": 288534, + "metrics": { + "B/op": 2328, + "allocs/op": 54, + "ns/op": 4478 + }, + "raw": "BenchmarkUnmarshalSSRBootstrapJSON-20 \t 288534\t 4478 ns/op\t 2328 B/op\t 54 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2328, + "allocs/op": 54, + "ns/op": 4478 + } + }, + { + "name": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "samples": [ + { + "iterations": 396973, + "metrics": { + "B/op": 1976, + "allocs/op": 42, + "ns/op": 3234 + }, + "raw": "BenchmarkUnmarshalSSRBootstrapBinary-20 \t 396973\t 3234 ns/op\t 1976 B/op\t 42 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1976, + "allocs/op": 42, + "ns/op": 3234 + } + }, + { + "name": "BenchmarkRenderBootstrapReferenceScript-20", + "samples": [ + { + "iterations": 857319, + "metrics": { + "B/op": 1753, + "allocs/op": 19, + "ns/op": 2207 + }, + "raw": "BenchmarkRenderBootstrapReferenceScript-20 \t 857319\t 2207 ns/op\t 1753 B/op\t 19 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1753, + "allocs/op": 19, + "ns/op": 2207 + } + } + ] + }, + { + "lane": "native", + "package": "./virtualization", + "workspace": "./virtualization", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkComputeViewportStateMicro-20", + "samples": [ + { + "iterations": 137581749, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.78 + }, + "raw": "BenchmarkComputeViewportStateMicro-20 \t137581749\t 8.780 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.78 + } + }, + { + "name": "BenchmarkComputeViewportState-20", + "samples": [ + { + "iterations": 71924766, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.7 + }, + "raw": "BenchmarkComputeViewportState-20 \t71924766\t 16.70 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.7 + } + }, + { + "name": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "samples": [ + { + "iterations": 63656086, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.1 + }, + "raw": "BenchmarkViewportDiagnosticsWithRowLifecycle-20 \t63656086\t 19.10 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.1 + } + } + ] + }, + { + "lane": "wasm", + "package": "./fetch", + "workspace": "./fetch", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 5, + "benchmarks": [ + { + "name": "BenchmarkResolveMutationQueueOptions", + "samples": [ + { + "iterations": 38634620, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 28.64 + }, + "raw": "BenchmarkResolveMutationQueueOptions \t38634620\t 28.64 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 28.64 + } + }, + { + "name": "BenchmarkNormalizeMutationID", + "samples": [ + { + "iterations": 2826058, + "metrics": { + "B/op": 40, + "allocs/op": 2, + "ns/op": 425.6 + }, + "raw": "BenchmarkNormalizeMutationID \t 2826058\t 425.6 ns/op\t 40 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 40, + "allocs/op": 2, + "ns/op": 425.6 + } + }, + { + "name": "BenchmarkMergeResolvedMutation", + "samples": [ + { + "iterations": 642836, + "metrics": { + "B/op": 696, + "allocs/op": 6, + "ns/op": 2033 + }, + "raw": "BenchmarkMergeResolvedMutation \t 642836\t 2033 ns/op\t 696 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 696, + "allocs/op": 6, + "ns/op": 2033 + } + }, + { + "name": "BenchmarkBuildMultipartFormData", + "samples": [ + { + "iterations": 14265, + "metrics": { + "B/op": 392, + "allocs/op": 35, + "ns/op": 91062 + }, + "raw": "BenchmarkBuildMultipartFormData \t 14265\t 91062 ns/op\t 392 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 392, + "allocs/op": 35, + "ns/op": 91062 + } + }, + { + "name": "BenchmarkNormalizeMutationIDMicro", + "samples": [ + { + "iterations": 2447402, + "metrics": { + "B/op": 63, + "allocs/op": 2, + "ns/op": 645.1 + }, + "raw": "BenchmarkNormalizeMutationIDMicro \t 2447402\t 645.1 ns/op\t 63 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 63, + "allocs/op": 2, + "ns/op": 645.1 + } + } + ] + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "workspace": "./internal/platform/jsdom", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 13, + "benchmarks": [ + { + "name": "BenchmarkWASMDOMAdapterCreateElement", + "samples": [ + { + "iterations": 32269, + "metrics": { + "B/op": 248, + "allocs/op": 24, + "ns/op": 31740 + }, + "raw": "BenchmarkWASMDOMAdapterCreateElement \t 32269\t 31740 ns/op\t 248 B/op\t 24 allocs/op" + } + ], + "averageMetrics": { + "B/op": 248, + "allocs/op": 24, + "ns/op": 31740 + } + }, + { + "name": "BenchmarkWASMDOMAdapterSetAttribute", + "samples": [ + { + "iterations": 73839, + "metrics": { + "B/op": 136, + "allocs/op": 13, + "ns/op": 16730 + }, + "raw": "BenchmarkWASMDOMAdapterSetAttribute \t 73839\t 16730 ns/op\t 136 B/op\t 13 allocs/op" + } + ], + "averageMetrics": { + "B/op": 136, + "allocs/op": 13, + "ns/op": 16730 + } + }, + { + "name": "BenchmarkWASMDOMAdapterAppendChild", + "samples": [ + { + "iterations": 28404, + "metrics": { + "B/op": 344, + "allocs/op": 33, + "ns/op": 47405 + }, + "raw": "BenchmarkWASMDOMAdapterAppendChild \t 28404\t 47405 ns/op\t 344 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 344, + "allocs/op": 33, + "ns/op": 47405 + } + }, + { + "name": "BenchmarkWASMDOMAdapterQuerySelector", + "samples": [ + { + "iterations": 40611, + "metrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 34559 + }, + "raw": "BenchmarkWASMDOMAdapterQuerySelector \t 40611\t 34559 ns/op\t 240 B/op\t 23 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 34559 + } + }, + { + "name": "BenchmarkWASMDOMAdapterGetElementById", + "samples": [ + { + "iterations": 39772, + "metrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 33020 + }, + "raw": "BenchmarkWASMDOMAdapterGetElementById \t 39772\t 33020 ns/op\t 240 B/op\t 23 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 23, + "ns/op": 33020 + } + }, + { + "name": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "samples": [ + { + "iterations": 32931, + "metrics": { + "B/op": 333, + "allocs/op": 27, + "ns/op": 39267 + }, + "raw": "BenchmarkWASMDOMAdapterQuerySelectorAll \t 32931\t 39267 ns/op\t 333 B/op\t 27 allocs/op" + } + ], + "averageMetrics": { + "B/op": 333, + "allocs/op": 27, + "ns/op": 39267 + } + }, + { + "name": "BenchmarkWASMDOMAdapterSetPropertyString", + "samples": [ + { + "iterations": 731906, + "metrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 1929 + }, + "raw": "BenchmarkWASMDOMAdapterSetPropertyString \t 731906\t 1929 ns/op\t 8 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 1929 + } + }, + { + "name": "BenchmarkWASMDOMAdapterBatchAppend16", + "samples": [ + { + "iterations": 4940, + "metrics": { + "B/op": 1777, + "allocs/op": 171, + "ns/op": 342044 + }, + "raw": "BenchmarkWASMDOMAdapterBatchAppend16 \t 4940\t 342044 ns/op\t 1777 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1777, + "allocs/op": 171, + "ns/op": 342044 + } + }, + { + "name": "BenchmarkWASMEventAdapterAddRemoveListener", + "samples": [ + { + "iterations": 42726, + "metrics": { + "B/op": 192, + "allocs/op": 16, + "ns/op": 37881 + }, + "raw": "BenchmarkWASMEventAdapterAddRemoveListener \t 42726\t 37881 ns/op\t 192 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 16, + "ns/op": 37881 + } + }, + { + "name": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "samples": [ + { + "iterations": 214599, + "metrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6480 + }, + "raw": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke \t 214599\t 6480 ns/op\t 32 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6480 + } + }, + { + "name": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "samples": [ + { + "iterations": 116655, + "metrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 12273 + }, + "raw": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke \t 116655\t 12273 ns/op\t 80 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 12273 + } + }, + { + "name": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "samples": [ + { + "iterations": 203456, + "metrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6288 + }, + "raw": "BenchmarkLegacyWrapFunctionNoArgsInvoke \t 203456\t 6288 ns/op\t 32 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32, + "allocs/op": 3, + "ns/op": 6288 + } + }, + { + "name": "BenchmarkLegacyWrapFunctionStringInvoke", + "samples": [ + { + "iterations": 115045, + "metrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 10787 + }, + "raw": "BenchmarkLegacyWrapFunctionStringInvoke \t 115045\t 10787 ns/op\t 80 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 80, + "allocs/op": 8, + "ns/op": 10787 + } + } + ] + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "workspace": "./internal/runtime", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 82, + "benchmarks": [ + { + "name": "BenchmarkGoEventGetValue", + "samples": [ + { + "iterations": 326613, + "metrics": { + "B/op": 24, + "allocs/op": 3, + "ns/op": 3434 + }, + "raw": "BenchmarkGoEventGetValue \t 326613\t 3434 ns/op\t 24 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 3, + "ns/op": 3434 + } + }, + { + "name": "BenchmarkGoEventIsChecked", + "samples": [ + { + "iterations": 677570, + "metrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 1907 + }, + "raw": "BenchmarkGoEventIsChecked \t 677570\t 1907 ns/op\t 8 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 1907 + } + }, + { + "name": "BenchmarkGoEventGetKey", + "samples": [ + { + "iterations": 712450, + "metrics": { + "B/op": 16, + "allocs/op": 2, + "ns/op": 1861 + }, + "raw": "BenchmarkGoEventGetKey \t 712450\t 1861 ns/op\t 16 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 16, + "allocs/op": 2, + "ns/op": 1861 + } + }, + { + "name": "BenchmarkGoEventGetKeyCode", + "samples": [ + { + "iterations": 4332350, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 276.7 + }, + "raw": "BenchmarkGoEventGetKeyCode \t 4332350\t 276.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 276.7 + } + }, + { + "name": "BenchmarkGoEventGetTarget", + "samples": [ + { + "iterations": 773629, + "metrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 1903 + }, + "raw": "BenchmarkGoEventGetTarget \t 773629\t 1903 ns/op\t 24 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 1903 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "samples": [ + { + "iterations": 7857, + "metrics": { + "B/op": 41535, + "allocs/op": 146, + "ns/op": 134323 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16 \t 7857\t 134323 ns/op\t 41535 B/op\t 146 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41535, + "allocs/op": 146, + "ns/op": 134323 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "samples": [ + { + "iterations": 21890, + "metrics": { + "B/op": 32851, + "allocs/op": 7, + "ns/op": 49607 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16 \t 21890\t 49607 ns/op\t 32851 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32851, + "allocs/op": 7, + "ns/op": 49607 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 41650, + "allocs/op": 130, + "ns/op": 114382 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16 \t 10000\t 114382 ns/op\t 41650 B/op\t 130 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41650, + "allocs/op": 130, + "ns/op": 114382 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "samples": [ + { + "iterations": 23080, + "metrics": { + "B/op": 32926, + "allocs/op": 10, + "ns/op": 53190 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16 \t 23080\t 53190 ns/op\t 32926 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 32926, + "allocs/op": 10, + "ns/op": 53190 + } + }, + { + "name": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "samples": [ + { + "iterations": 16198, + "metrics": { + "B/op": 33277, + "allocs/op": 17, + "ns/op": 74074 + }, + "raw": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16 \t 16198\t 74074 ns/op\t 33277 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33277, + "allocs/op": 17, + "ns/op": 74074 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "samples": [ + { + "iterations": 9409, + "metrics": { + "B/op": 35019, + "allocs/op": 32, + "ns/op": 211598 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64 \t 9409\t 211598 ns/op\t 35019 B/op\t 32 allocs/op" + } + ], + "averageMetrics": { + "B/op": 35019, + "allocs/op": 32, + "ns/op": 211598 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "samples": [ + { + "iterations": 9777, + "metrics": { + "B/op": 35052, + "allocs/op": 32, + "ns/op": 252300 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64 \t 9777\t 252300 ns/op\t 35052 B/op\t 32 allocs/op" + } + ], + "averageMetrics": { + "B/op": 35052, + "allocs/op": 32, + "ns/op": 252300 + } + }, + { + "name": "BenchmarkIsNilableTypeCachedPointer", + "samples": [ + { + "iterations": 9543091, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 108.8 + }, + "raw": "BenchmarkIsNilableTypeCachedPointer \t 9543091\t 108.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 108.8 + } + }, + { + "name": "BenchmarkFastEqualInt", + "samples": [ + { + "iterations": 100000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10.61 + }, + "raw": "BenchmarkFastEqualInt \t100000000\t 10.61 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10.61 + } + }, + { + "name": "BenchmarkFastEqualString", + "samples": [ + { + "iterations": 80109033, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.06 + }, + "raw": "BenchmarkFastEqualString \t80109033\t 14.06 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.06 + } + }, + { + "name": "BenchmarkAreDepsEqual3Primitives", + "samples": [ + { + "iterations": 31640014, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 37.64 + }, + "raw": "BenchmarkAreDepsEqual3Primitives \t31640014\t 37.64 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 37.64 + } + }, + { + "name": "BenchmarkGoUseStateIntDirectUpdate", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 1063 + }, + "raw": "BenchmarkGoUseStateIntDirectUpdate \t 1000000\t 1063 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 1063 + } + }, + { + "name": "BenchmarkGoUseStatePointerNilReset", + "samples": [ + { + "iterations": 903492, + "metrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 1132 + }, + "raw": "BenchmarkGoUseStatePointerNilReset \t 903492\t 1132 ns/op\t 436 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 436, + "allocs/op": 2, + "ns/op": 1132 + } + }, + { + "name": "BenchmarkGoUseMemoSameDeps", + "samples": [ + { + "iterations": 2875803, + "metrics": { + "B/op": 109, + "allocs/op": 1, + "ns/op": 351.6 + }, + "raw": "BenchmarkGoUseMemoSameDeps \t 2875803\t 351.6 ns/op\t 109 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 109, + "allocs/op": 1, + "ns/op": 351.6 + } + }, + { + "name": "BenchmarkGoUseCallbackSameDeps", + "samples": [ + { + "iterations": 4790965, + "metrics": { + "B/op": 104, + "allocs/op": 1, + "ns/op": 304.2 + }, + "raw": "BenchmarkGoUseCallbackSameDeps \t 4790965\t 304.2 ns/op\t 104 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 104, + "allocs/op": 1, + "ns/op": 304.2 + } + }, + { + "name": "BenchmarkGoUseRefStable", + "samples": [ + { + "iterations": 7795790, + "metrics": { + "B/op": 84, + "allocs/op": 0, + "ns/op": 172.4 + }, + "raw": "BenchmarkGoUseRefStable \t 7795790\t 172.4 ns/op\t 84 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 84, + "allocs/op": 0, + "ns/op": 172.4 + } + }, + { + "name": "BenchmarkGoUseIdStable", + "samples": [ + { + "iterations": 6066507, + "metrics": { + "B/op": 87, + "allocs/op": 0, + "ns/op": 209.9 + }, + "raw": "BenchmarkGoUseIdStable \t 6066507\t 209.9 ns/op\t 87 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 87, + "allocs/op": 0, + "ns/op": 209.9 + } + }, + { + "name": "BenchmarkGoUseFuncWrap", + "samples": [ + { + "iterations": 2673972, + "metrics": { + "B/op": 120, + "allocs/op": 2, + "ns/op": 592.2 + }, + "raw": "BenchmarkGoUseFuncWrap \t 2673972\t 592.2 ns/op\t 120 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 120, + "allocs/op": 2, + "ns/op": 592.2 + } + }, + { + "name": "BenchmarkGoUseEffectSameDeps", + "samples": [ + { + "iterations": 3257028, + "metrics": { + "B/op": 98, + "allocs/op": 1, + "ns/op": 451.9 + }, + "raw": "BenchmarkGoUseEffectSameDeps \t 3257028\t 451.9 ns/op\t 98 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 98, + "allocs/op": 1, + "ns/op": 451.9 + } + }, + { + "name": "BenchmarkGoUseFetchInit", + "samples": [ + { + "iterations": 937855, + "metrics": { + "B/op": 680, + "allocs/op": 5, + "ns/op": 1118 + }, + "raw": "BenchmarkGoUseFetchInit \t 937855\t 1118 ns/op\t 680 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 680, + "allocs/op": 5, + "ns/op": 1118 + } + }, + { + "name": "BenchmarkGoUseFetchRefetchUnavailable", + "samples": [ + { + "iterations": 100, + "metrics": { + "B/op": 82, + "allocs/op": 3, + "ns/op": 15529536 + }, + "raw": "BenchmarkGoUseFetchRefetchUnavailable \t 100\t 15529536 ns/op\t 82 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 82, + "allocs/op": 3, + "ns/op": 15529536 + } + }, + { + "name": "BenchmarkDivWithTextChildren", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1255 + }, + "raw": "BenchmarkDivWithTextChildren \t 1000000\t 1255 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1255 + } + }, + { + "name": "BenchmarkDivWithComponents4", + "samples": [ + { + "iterations": 947619, + "metrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 1320 + }, + "raw": "BenchmarkDivWithComponents4 \t 947619\t 1320 ns/op\t 744 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 744, + "allocs/op": 9, + "ns/op": 1320 + } + }, + { + "name": "BenchmarkWithComponentsGeneric4", + "samples": [ + { + "iterations": 990282, + "metrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 1739 + }, + "raw": "BenchmarkWithComponentsGeneric4 \t 990282\t 1739 ns/op\t 760 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 760, + "allocs/op": 10, + "ns/op": 1739 + } + }, + { + "name": "BenchmarkHydrateSimpleReuse", + "samples": [ + { + "iterations": 28173, + "metrics": { + "B/op": 8520, + "allocs/op": 70, + "ns/op": 40888 + }, + "raw": "BenchmarkHydrateSimpleReuse \t 28173\t 40888 ns/op\t 8520 B/op\t 70 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8520, + "allocs/op": 70, + "ns/op": 40888 + } + }, + { + "name": "BenchmarkHydrateTagMismatchFallback", + "samples": [ + { + "iterations": 17872, + "metrics": { + "B/op": 9192, + "allocs/op": 83, + "ns/op": 76790 + }, + "raw": "BenchmarkHydrateTagMismatchFallback \t 17872\t 76790 ns/op\t 9192 B/op\t 83 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9192, + "allocs/op": 83, + "ns/op": 76790 + } + }, + { + "name": "BenchmarkHydrateMediumTreeReuse", + "samples": [ + { + "iterations": 363, + "metrics": { + "B/op": 430012, + "allocs/op": 6019, + "ns/op": 3135983 + }, + "raw": "BenchmarkHydrateMediumTreeReuse \t 363\t 3135983 ns/op\t 430012 B/op\t 6019 allocs/op" + } + ], + "averageMetrics": { + "B/op": 430012, + "allocs/op": 6019, + "ns/op": 3135983 + } + }, + { + "name": "BenchmarkHydrateMediumTreeFirstUpdate", + "samples": [ + { + "iterations": 457, + "metrics": { + "B/op": 450353, + "allocs/op": 5757, + "ns/op": 2516709 + }, + "raw": "BenchmarkHydrateMediumTreeFirstUpdate \t 457\t 2516709 ns/op\t 450353 B/op\t 5757 allocs/op" + } + ], + "averageMetrics": { + "B/op": 450353, + "allocs/op": 5757, + "ns/op": 2516709 + } + }, + { + "name": "BenchmarkDOMNodeInterfaceEquals", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.8077 + }, + "raw": "BenchmarkDOMNodeInterfaceEquals \t1000000000\t 0.8077 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.8077 + } + }, + { + "name": "BenchmarkDOMAdapterInterfaceCreateElement", + "samples": [ + { + "iterations": 25689576, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 57.54 + }, + "raw": "BenchmarkDOMAdapterInterfaceCreateElement \t25689576\t 57.54 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 57.54 + } + }, + { + "name": "BenchmarkSchedulerInterfaceSetTimeout", + "samples": [ + { + "iterations": 7010886, + "metrics": { + "B/op": 48, + "allocs/op": 0, + "ns/op": 269.6 + }, + "raw": "BenchmarkSchedulerInterfaceSetTimeout \t 7010886\t 269.6 ns/op\t 48 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 0, + "ns/op": 269.6 + } + }, + { + "name": "BenchmarkRuntimeLayoutBaselines", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.5231 + }, + "raw": "BenchmarkRuntimeLayoutBaselines \t1000000000\t 0.5231 ns/op\t 64.00 element-bytes\t 40.00 fetchstate-bytes\t 8.000 fiber-align\t 344.0 fiber-bytes\t 8.000 hooks-align\t 424.0 hooks-bytes\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 64, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 344, + "hooks-align": 8, + "hooks-bytes": 424, + "ns/op": 0.5231 + } + }, + { + "name": "BenchmarkFiberHotFieldScan256", + "samples": [ + { + "iterations": 1621537, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 733.8 + }, + "raw": "BenchmarkFiberHotFieldScan256 \t 1621537\t 733.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 733.8 + } + }, + { + "name": "BenchmarkFiberSiblingWalk256", + "samples": [ + { + "iterations": 3691674, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 312.2 + }, + "raw": "BenchmarkFiberSiblingWalk256 \t 3691674\t 312.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 312.2 + } + }, + { + "name": "BenchmarkHooksIndexResetHotPath", + "samples": [ + { + "iterations": 133754384, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.963 + }, + "raw": "BenchmarkHooksIndexResetHotPath \t133754384\t 8.963 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.963 + } + }, + { + "name": "BenchmarkRenderPortalToSelector", + "samples": [ + { + "iterations": 41294, + "metrics": { + "B/op": 7796, + "allocs/op": 55, + "ns/op": 32331 + }, + "raw": "BenchmarkRenderPortalToSelector \t 41294\t 32331 ns/op\t 7796 B/op\t 55 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7796, + "allocs/op": 55, + "ns/op": 32331 + } + }, + { + "name": "BenchmarkCreateElementHostWithTextChildren", + "samples": [ + { + "iterations": 802666, + "metrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1453 + }, + "raw": "BenchmarkCreateElementHostWithTextChildren \t 802666\t 1453 ns/op\t 664 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 8, + "ns/op": 1453 + } + }, + { + "name": "BenchmarkPropsEqualChildrenSamePointer", + "samples": [ + { + "iterations": 6511465, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 187.3 + }, + "raw": "BenchmarkPropsEqualChildrenSamePointer \t 6511465\t 187.3 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 187.3 + } + }, + { + "name": "BenchmarkPropsEqualChildrenDifferentPointer", + "samples": [ + { + "iterations": 7595754, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 160.5 + }, + "raw": "BenchmarkPropsEqualChildrenDifferentPointer \t 7595754\t 160.5 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 160.5 + } + }, + { + "name": "BenchmarkReconcileChildrenStableList16", + "samples": [ + { + "iterations": 78597, + "metrics": { + "B/op": 5632, + "allocs/op": 16, + "ns/op": 17975 + }, + "raw": "BenchmarkReconcileChildrenStableList16 \t 78597\t 17975 ns/op\t 5632 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5632, + "allocs/op": 16, + "ns/op": 17975 + } + }, + { + "name": "BenchmarkReconcileChildrenWithFragments16", + "samples": [ + { + "iterations": 64917, + "metrics": { + "B/op": 5656, + "allocs/op": 17, + "ns/op": 20499 + }, + "raw": "BenchmarkReconcileChildrenWithFragments16 \t 64917\t 20499 ns/op\t 5656 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5656, + "allocs/op": 17, + "ns/op": 20499 + } + }, + { + "name": "BenchmarkReconcileChildrenKeyedStableList16", + "samples": [ + { + "iterations": 51938, + "metrics": { + "B/op": 5681, + "allocs/op": 18, + "ns/op": 26206 + }, + "raw": "BenchmarkReconcileChildrenKeyedStableList16 \t 51938\t 26206 ns/op\t 5681 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5681, + "allocs/op": 18, + "ns/op": 26206 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "samples": [ + { + "iterations": 168199, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 7045 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf \t 168199\t 7045 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 7045 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "samples": [ + { + "iterations": 239235, + "metrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 4929 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf \t 239235\t 4929 ns/op\t 968 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 968, + "allocs/op": 5, + "ns/op": 4929 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesInitialRender", + "samples": [ + { + "iterations": 501926, + "metrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 2512 + }, + "raw": "BenchmarkUpdateDomPropertiesInitialRender \t 501926\t 2512 ns/op\t 1120 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 2512 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesSteadyState", + "samples": [ + { + "iterations": 787669, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2105 + }, + "raw": "BenchmarkUpdateDomPropertiesSteadyState \t 787669\t 2105 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2105 + } + }, + { + "name": "BenchmarkCommitDeletionDomlessSubtree32", + "samples": [ + { + "iterations": 24974, + "metrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 49053 + }, + "raw": "BenchmarkCommitDeletionDomlessSubtree32 \t 24974\t 49053 ns/op\t 21072 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 21072, + "allocs/op": 171, + "ns/op": 49053 + } + }, + { + "name": "BenchmarkCommitWorkPlacementChain16", + "samples": [ + { + "iterations": 178866, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6658 + }, + "raw": "BenchmarkCommitWorkPlacementChain16 \t 178866\t 6658 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6658 + } + }, + { + "name": "BenchmarkRunEffectsChain16", + "samples": [ + { + "iterations": 219142, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 5519 + }, + "raw": "BenchmarkRunEffectsChain16 \t 219142\t 5519 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 5519 + } + }, + { + "name": "BenchmarkGetGlobalRuntimeLazy", + "samples": [ + { + "iterations": 864517, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 1319 + }, + "raw": "BenchmarkGetGlobalRuntimeLazy \t 864517\t 1319 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 1319 + } + }, + { + "name": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 1151 + }, + "raw": "BenchmarkInitGlobalRuntimeAfterLazyGet \t 1000000\t 1151 ns/op\t 1312 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1312, + "allocs/op": 6, + "ns/op": 1151 + } + }, + { + "name": "BenchmarkRenderTo", + "samples": [ + { + "iterations": 125850, + "metrics": { + "B/op": 3112, + "allocs/op": 20, + "ns/op": 8436 + }, + "raw": "BenchmarkRenderTo \t 125850\t 8436 ns/op\t 3112 B/op\t 20 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3112, + "allocs/op": 20, + "ns/op": 8436 + } + }, + { + "name": "BenchmarkScheduleUpdate", + "samples": [ + { + "iterations": 2210852, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 523.5 + }, + "raw": "BenchmarkScheduleUpdate \t 2210852\t 523.5 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 523.5 + } + }, + { + "name": "BenchmarkScheduleUpdateSteadyState", + "samples": [ + { + "iterations": 2404958, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 513.1 + }, + "raw": "BenchmarkScheduleUpdateSteadyState \t 2404958\t 513.1 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 513.1 + } + }, + { + "name": "BenchmarkScheduleUpdateForFiberDepth32", + "samples": [ + { + "iterations": 1711024, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 727.3 + }, + "raw": "BenchmarkScheduleUpdateForFiberDepth32 \t 1711024\t 727.3 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 727.3 + } + }, + { + "name": "BenchmarkRender", + "samples": [ + { + "iterations": 42099, + "metrics": { + "B/op": 33995, + "allocs/op": 11, + "ns/op": 34791 + }, + "raw": "BenchmarkRender \t 42099\t 34791 ns/op\t 33995 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33995, + "allocs/op": 11, + "ns/op": 34791 + } + }, + { + "name": "BenchmarkRenderSteadyState", + "samples": [ + { + "iterations": 35521, + "metrics": { + "B/op": 33959, + "allocs/op": 11, + "ns/op": 42658 + }, + "raw": "BenchmarkRenderSteadyState \t 35521\t 42658 ns/op\t 33959 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33959, + "allocs/op": 11, + "ns/op": 42658 + } + }, + { + "name": "BenchmarkEnqueueUI", + "samples": [ + { + "iterations": 11044405, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 109.8 + }, + "raw": "BenchmarkEnqueueUI \t11044405\t 109.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 109.8 + } + }, + { + "name": "BenchmarkProcessUIQueueBatch64", + "samples": [ + { + "iterations": 189870, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6745 + }, + "raw": "BenchmarkProcessUIQueueBatch64 \t 189870\t 6745 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6745 + } + }, + { + "name": "BenchmarkTransitionListRefresh250", + "samples": [ + { + "iterations": 849, + "metrics": { + "B/op": 229709, + "allocs/op": 1789, + "ns/op": 1526483 + }, + "raw": "BenchmarkTransitionListRefresh250 \t 849\t 1526483 ns/op\t 229709 B/op\t 1789 allocs/op" + } + ], + "averageMetrics": { + "B/op": 229709, + "allocs/op": 1789, + "ns/op": 1526483 + } + }, + { + "name": "BenchmarkTextShim", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.6564 + }, + "raw": "BenchmarkTextShim \t1000000000\t 0.6564 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.6564 + } + }, + { + "name": "BenchmarkGoUseStateGlobalInit", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 1024, + "allocs/op": 7, + "ns/op": 1408 + }, + "raw": "BenchmarkGoUseStateGlobalInit \t 1000000\t 1408 ns/op\t 1024 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1024, + "allocs/op": 7, + "ns/op": 1408 + } + }, + { + "name": "BenchmarkGoUseAtomGlobalInit", + "samples": [ + { + "iterations": 414074, + "metrics": { + "B/op": 1141, + "allocs/op": 9, + "ns/op": 3454 + }, + "raw": "BenchmarkGoUseAtomGlobalInit \t 414074\t 3454 ns/op\t 1141 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1141, + "allocs/op": 9, + "ns/op": 3454 + } + }, + { + "name": "BenchmarkAtomRegistryInitAtomExisting", + "samples": [ + { + "iterations": 10909585, + "metrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 100.9 + }, + "raw": "BenchmarkAtomRegistryInitAtomExisting \t10909585\t 100.9 ns/op\t 7 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 100.9 + } + }, + { + "name": "BenchmarkAtomRegistryGetAtom", + "samples": [ + { + "iterations": 31494396, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 39.02 + }, + "raw": "BenchmarkAtomRegistryGetAtom \t31494396\t 39.02 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 39.02 + } + }, + { + "name": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "samples": [ + { + "iterations": 1572002, + "metrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 761.2 + }, + "raw": "BenchmarkAtomRegistrySubscribeUnsubscribe \t 1572002\t 761.2 ns/op\t 192 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 761.2 + } + }, + { + "name": "BenchmarkAtomRegistrySetAtom32Subscribers", + "samples": [ + { + "iterations": 997956, + "metrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 2737 + }, + "raw": "BenchmarkAtomRegistrySetAtom32Subscribers \t 997956\t 2737 ns/op\t 264 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 2737 + } + }, + { + "name": "BenchmarkGoUseAtomIntUpdate", + "samples": [ + { + "iterations": 806714, + "metrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 1959 + }, + "raw": "BenchmarkGoUseAtomIntUpdate \t 806714\t 1959 ns/op\t 472 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 472, + "allocs/op": 6, + "ns/op": 1959 + } + }, + { + "name": "BenchmarkGoUseAtomPointerNilReset", + "samples": [ + { + "iterations": 712440, + "metrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 1651 + }, + "raw": "BenchmarkGoUseAtomPointerNilReset \t 712440\t 1651 ns/op\t 444 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 444, + "allocs/op": 3, + "ns/op": 1651 + } + }, + { + "name": "BenchmarkGoUseAtomGetter", + "samples": [ + { + "iterations": 26334860, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 46.19 + }, + "raw": "BenchmarkGoUseAtomGetter \t26334860\t 46.19 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 46.19 + } + }, + { + "name": "BenchmarkGoUseAtomStableRerender", + "samples": [ + { + "iterations": 3077874, + "metrics": { + "B/op": 87, + "allocs/op": 0, + "ns/op": 344.1 + }, + "raw": "BenchmarkGoUseAtomStableRerender \t 3077874\t 344.1 ns/op\t 87 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 87, + "allocs/op": 0, + "ns/op": 344.1 + } + }, + { + "name": "BenchmarkCleanupAtomSubscriptions8", + "samples": [ + { + "iterations": 209022, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 5556 + }, + "raw": "BenchmarkCleanupAtomSubscriptions8 \t 209022\t 5556 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 5556 + } + }, + { + "name": "BenchmarkAtomRegistryUnsubscribeMany8", + "samples": [ + { + "iterations": 179988, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 6383 + }, + "raw": "BenchmarkAtomRegistryUnsubscribeMany8 \t 179988\t 6383 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 6383 + } + }, + { + "name": "BenchmarkFiberAllocation", + "samples": [ + { + "iterations": 24442323, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 43.91 + }, + "raw": "BenchmarkFiberAllocation \t24442323\t 43.91 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 43.91 + } + }, + { + "name": "BenchmarkElementLiteralCreation", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5322 + }, + "raw": "BenchmarkElementLiteralCreation \t1000000000\t 0.5322 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5322 + } + }, + { + "name": "BenchmarkHooksPackedStateRead", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5656 + }, + "raw": "BenchmarkHooksPackedStateRead \t1000000000\t 0.5656 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.5656 + } + }, + { + "name": "BenchmarkFetchStateCopy", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.534 + }, + "raw": "BenchmarkFetchStateCopy \t1000000000\t 0.5340 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.534 + } + } + ] + }, + { + "lane": "wasm", + "package": "./interop", + "workspace": "./interop", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 5, + "benchmarks": [ + { + "name": "BenchmarkDecodeMapToStruct", + "samples": [ + { + "iterations": 100438, + "metrics": { + "B/op": 1136, + "allocs/op": 29, + "ns/op": 11579 + }, + "raw": "BenchmarkDecodeMapToStruct \t 100438\t 11579 ns/op\t 1136 B/op\t 29 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1136, + "allocs/op": 29, + "ns/op": 11579 + } + }, + { + "name": "BenchmarkInteropErrorString", + "samples": [ + { + "iterations": 1785199, + "metrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 674.9 + }, + "raw": "BenchmarkInteropErrorString \t 1785199\t 674.9 ns/op\t 480 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 674.9 + } + }, + { + "name": "BenchmarkLocalStorageGetItem", + "samples": [ + { + "iterations": 73142, + "metrics": { + "B/op": 96, + "allocs/op": 10, + "ns/op": 14119 + }, + "raw": "BenchmarkLocalStorageGetItem \t 73142\t 14119 ns/op\t 96 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 96, + "allocs/op": 10, + "ns/op": 14119 + } + }, + { + "name": "BenchmarkModuleCall", + "samples": [ + { + "iterations": 104042, + "metrics": { + "B/op": 128, + "allocs/op": 11, + "ns/op": 11827 + }, + "raw": "BenchmarkModuleCall \t 104042\t 11827 ns/op\t 128 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 128, + "allocs/op": 11, + "ns/op": 11827 + } + }, + { + "name": "BenchmarkClientCanExchangeMicro", + "samples": [ + { + "iterations": 4549314, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 266.7 + }, + "raw": "BenchmarkClientCanExchangeMicro \t 4549314\t 266.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 266.7 + } + } + ] + }, + { + "lane": "wasm", + "package": "./router", + "workspace": "./router", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkRouteContractMustHrefForMicro", + "samples": [ + { + "iterations": 365080, + "metrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 2812 + }, + "raw": "BenchmarkRouteContractMustHrefForMicro \t 365080\t 2812 ns/op\t 952 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 2812 + } + }, + { + "name": "BenchmarkResolveRouteStackNestedLayout", + "samples": [ + { + "iterations": 330026, + "metrics": { + "B/op": 1808, + "allocs/op": 15, + "ns/op": 3503 + }, + "raw": "BenchmarkResolveRouteStackNestedLayout \t 330026\t 3503 ns/op\t 1808 B/op\t 15 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1808, + "allocs/op": 15, + "ns/op": 3503 + } + }, + { + "name": "BenchmarkCurrentNestedLayoutRoute", + "samples": [ + { + "iterations": 1076, + "metrics": { + "B/op": 12228, + "allocs/op": 685, + "ns/op": 1136635 + }, + "raw": "BenchmarkCurrentNestedLayoutRoute \t 1076\t 1136635 ns/op\t 12228 B/op\t 685 allocs/op" + } + ], + "averageMetrics": { + "B/op": 12228, + "allocs/op": 685, + "ns/op": 1136635 + } + }, + { + "name": "BenchmarkEvaluateNavigationNestedLayouts", + "samples": [ + { + "iterations": 43408, + "metrics": { + "B/op": 3552, + "allocs/op": 41, + "ns/op": 30824 + }, + "raw": "BenchmarkEvaluateNavigationNestedLayouts \t 43408\t 30824 ns/op\t 3552 B/op\t 41 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3552, + "allocs/op": 41, + "ns/op": 30824 + } + } + ] + }, + { + "lane": "wasm", + "package": "./state", + "workspace": "./state", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkMarshalSnapshotJSONMicro", + "samples": [ + { + "iterations": 300447, + "metrics": { + "B/op": 448, + "allocs/op": 13, + "ns/op": 4002 + }, + "raw": "BenchmarkMarshalSnapshotJSONMicro \t 300447\t 4002 ns/op\t 448 B/op\t 13 allocs/op" + } + ], + "averageMetrics": { + "B/op": 448, + "allocs/op": 13, + "ns/op": 4002 + } + }, + { + "name": "BenchmarkUnmarshalSnapshotJSONMicro", + "samples": [ + { + "iterations": 168908, + "metrics": { + "B/op": 1656, + "allocs/op": 25, + "ns/op": 7052 + }, + "raw": "BenchmarkUnmarshalSnapshotJSONMicro \t 168908\t 7052 ns/op\t 1656 B/op\t 25 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1656, + "allocs/op": 25, + "ns/op": 7052 + } + }, + { + "name": "BenchmarkSnapshotSelect", + "samples": [ + { + "iterations": 4282647, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 259.2 + }, + "raw": "BenchmarkSnapshotSelect \t 4282647\t 259.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 259.2 + } + }, + { + "name": "BenchmarkMarshalUnmarshalSnapshotJSON", + "samples": [ + { + "iterations": 90139, + "metrics": { + "B/op": 1528, + "allocs/op": 38, + "ns/op": 14264 + }, + "raw": "BenchmarkMarshalUnmarshalSnapshotJSON \t 90139\t 14264 ns/op\t 1528 B/op\t 38 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1528, + "allocs/op": 38, + "ns/op": 14264 + } + } + ] + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "workspace": "./testkit/hooks", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkRenderHookCurrentMicroWasm", + "samples": [ + { + "iterations": 163894990, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6.882 + }, + "raw": "BenchmarkRenderHookCurrentMicroWasm \t163894990\t 6.882 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6.882 + } + }, + { + "name": "BenchmarkRenderHookStateRerenderMicroWasm", + "samples": [ + { + "iterations": 14900, + "metrics": { + "B/op": 68085, + "allocs/op": 35, + "ns/op": 109077 + }, + "raw": "BenchmarkRenderHookStateRerenderMicroWasm \t 14900\t 109077 ns/op\t 68085 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 68085, + "allocs/op": 35, + "ns/op": 109077 + } + } + ] + }, + { + "lane": "wasm", + "package": "./testkit/router", + "workspace": "./testkit/router", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkCloneURLValuesMicroWasm", + "samples": [ + { + "iterations": 1751694, + "metrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 742.1 + }, + "raw": "BenchmarkCloneURLValuesMicroWasm \t 1751694\t 742.1 ns/op\t 48 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 742.1 + } + }, + { + "name": "BenchmarkCloneStringMapMicroWasm", + "samples": [ + { + "iterations": 5849692, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 281.9 + }, + "raw": "BenchmarkCloneStringMapMicroWasm \t 5849692\t 281.9 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 281.9 + } + } + ] + }, + { + "lane": "wasm", + "package": "./utils", + "workspace": "./utils", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "samples": [ + { + "iterations": 284686852, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.311 + }, + "raw": "BenchmarkConfigureAndReadMemStatsSampleRateMicro \t284686852\t 4.311 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.311 + } + }, + { + "name": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "samples": [ + { + "iterations": 1751508, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 799.7 + }, + "raw": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro \t 1751508\t 799.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 799.7 + } + } + ] + } + ], + "comparison": { + "baselineGeneratedAt": "2026-03-25T15:05:40Z", + "tolerancePct": 2, + "matchedMetrics": 747, + "improved": 129, + "regressed": 96, + "unchanged": 522, + "entries": [ + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookStateRerenderMicroWasm", + "metric": "ns/op", + "baseline": 56622, + "current": 109077, + "delta": 52455, + "deltaPct": 92.64066970435519, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback", + "metric": "ns/op", + "baseline": 41431, + "current": 76790, + "delta": 35359, + "deltaPct": 85.3443074026695, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkBuildMultipartFormData", + "metric": "ns/op", + "baseline": 54793, + "current": 91062, + "delta": 36269, + "deltaPct": 66.1927618491413, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookCurrentMicroWasm", + "metric": "ns/op", + "baseline": 4.255, + "current": 6.882, + "delta": 2.627, + "deltaPct": 61.73913043478261, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneStringMapMicroWasm", + "metric": "ns/op", + "baseline": 177.8, + "current": 281.9, + "delta": 104.09999999999997, + "deltaPct": 58.54893138357703, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "metric": "ns/op", + "baseline": 15384, + "current": 6646, + "delta": -8738, + "deltaPct": -56.79927197087884, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "metric": "ns/op", + "baseline": 4518, + "current": 7045, + "delta": 2527, + "deltaPct": 55.93182824258521, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset", + "metric": "ns/op", + "baseline": 733.4, + "current": 1132, + "delta": 398.6, + "deltaPct": 54.3496045814017, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "metric": "ns/op", + "baseline": 25196, + "current": 11512, + "delta": -13684, + "deltaPct": -54.31020796951898, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneURLValuesMicroWasm", + "metric": "ns/op", + "baseline": 486.8, + "current": 742.1, + "delta": 255.3, + "deltaPct": 52.44453574363188, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState", + "metric": "ns/op", + "baseline": 28196, + "current": 42658, + "delta": 14462, + "deltaPct": 51.29096325719961, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchInit", + "metric": "ns/op", + "baseline": 743.5, + "current": 1118, + "delta": 374.5, + "deltaPct": 50.369872225958304, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps", + "metric": "ns/op", + "baseline": 309.1, + "current": 451.9, + "delta": 142.79999999999995, + "deltaPct": 46.198641216434794, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkDivNodeConstructionMicro-20", + "metric": "ns/op", + "baseline": 457.3, + "current": 659, + "delta": 201.7, + "deltaPct": 44.10671331729718, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "metric": "ns/op", + "baseline": 36442, + "current": 21123, + "delta": -15319, + "deltaPct": -42.036660995554584, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse", + "metric": "ns/op", + "baseline": 2221417, + "current": 3135983, + "delta": 914566, + "deltaPct": 41.170388090124455, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate", + "metric": "ns/op", + "baseline": 3325, + "current": 1959, + "delta": -1366, + "deltaPct": -41.08270676691729, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy-20", + "metric": "ns/op", + "baseline": 0.1786, + "current": 0.1118, + "delta": -0.06680000000000001, + "deltaPct": -37.402015677491605, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250-20", + "metric": "ns/op", + "baseline": 377832, + "current": 237273, + "delta": -140559, + "deltaPct": -37.201454614749416, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate-20", + "metric": "ns/op", + "baseline": 350.8, + "current": 480.9, + "delta": 130.09999999999997, + "deltaPct": 37.086659064994286, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "metric": "ns/op", + "baseline": 1821, + "current": 1151, + "delta": -670, + "deltaPct": -36.792970895112575, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender-20", + "metric": "ns/op", + "baseline": 12444, + "current": 7882, + "delta": -4562, + "deltaPct": -36.66023786563806, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "metric": "ns/op", + "baseline": 41487, + "current": 26564, + "delta": -14923, + "deltaPct": -35.97030395063514, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation-20", + "metric": "ns/op", + "baseline": 0.1727, + "current": 0.1125, + "delta": -0.06019999999999999, + "deltaPct": -34.858135495078166, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset", + "metric": "ns/op", + "baseline": 2520, + "current": 1651, + "delta": -869, + "deltaPct": -34.48412698412698, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4", + "metric": "ns/op", + "baseline": 1327, + "current": 1739, + "delta": 412, + "deltaPct": 31.047475508666167, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines-20", + "metric": "ns/op", + "baseline": 0.1642, + "current": 0.1144, + "delta": -0.04980000000000001, + "deltaPct": -30.328867235079176, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "metric": "ns/op", + "baseline": 1065, + "current": 761.2, + "delta": -303.79999999999995, + "deltaPct": -28.52582159624413, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "metric": "ns/op", + "baseline": 36390, + "current": 46576, + "delta": 10186, + "deltaPct": 27.991206375377853, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32", + "metric": "ns/op", + "baseline": 994.2, + "current": 727.3, + "delta": -266.9000000000001, + "deltaPct": -26.845705089519218, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt-20", + "metric": "ns/op", + "baseline": 2.106, + "current": 1.548, + "delta": -0.5579999999999998, + "deltaPct": -26.49572649572649, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16", + "metric": "ns/op", + "baseline": 16315, + "current": 20499, + "delta": 4184, + "deltaPct": 25.6451118602513, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16", + "metric": "ns/op", + "baseline": 5309, + "current": 6658, + "delta": 1349, + "deltaPct": 25.40968167263138, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMEventAdapterAddRemoveListener", + "metric": "ns/op", + "baseline": 30258, + "current": 37881, + "delta": 7623, + "deltaPct": 25.193337299226652, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren-20", + "metric": "ns/op", + "baseline": 441.5, + "current": 331.4, + "delta": -110.10000000000002, + "deltaPct": -24.937712344280865, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateGlobalInit", + "metric": "ns/op", + "baseline": 1134, + "current": 1408, + "delta": 274, + "deltaPct": 24.16225749559083, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation", + "metric": "ns/op", + "baseline": 57.56, + "current": 43.91, + "delta": -13.650000000000006, + "deltaPct": -23.714384989576104, + "direction": "improved" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkClassNames-20", + "metric": "ns/op", + "baseline": 254.1, + "current": 314.2, + "delta": 60.099999999999994, + "deltaPct": 23.65210547028729, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGlobalInit", + "metric": "ns/op", + "baseline": 4510, + "current": 3454, + "delta": -1056, + "deltaPct": -23.414634146341466, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "metric": "ns/op", + "baseline": 648.9, + "current": 799.7, + "delta": 150.80000000000007, + "deltaPct": 23.239328093697036, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps-20", + "metric": "ns/op", + "baseline": 54.75, + "current": 42.1, + "delta": -12.649999999999999, + "deltaPct": -23.105022831050228, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro", + "metric": "ns/op", + "baseline": 346.7, + "current": 266.7, + "delta": -80, + "deltaPct": -23.07470435535045, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString-20", + "metric": "ns/op", + "baseline": 2.607, + "current": 2.007, + "delta": -0.6000000000000001, + "deltaPct": -23.014959723820485, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender", + "metric": "ns/op", + "baseline": 28284, + "current": 34791, + "delta": 6507, + "deltaPct": 23.00593975392448, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "metric": "ns/op", + "baseline": 15794, + "current": 12273, + "delta": -3521, + "deltaPct": -22.29327592756743, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetAttribute", + "metric": "ns/op", + "baseline": 21438, + "current": 16730, + "delta": -4708, + "deltaPct": -21.961003824983674, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "metric": "ns/op", + "baseline": 4046, + "current": 4929, + "delta": 883, + "deltaPct": 21.824023727137913, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterCreateElement", + "metric": "ns/op", + "baseline": 40500, + "current": 31740, + "delta": -8760, + "deltaPct": -21.62962962962963, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250", + "metric": "ns/op", + "baseline": 1259488, + "current": 1526483, + "delta": 266995, + "deltaPct": 21.198693437333265, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers", + "metric": "ns/op", + "baseline": 3469, + "current": 2737, + "delta": -732, + "deltaPct": -21.10118189680023, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "metric": "ns/op", + "baseline": 208403, + "current": 252300, + "delta": 43897, + "deltaPct": 21.06351636012917, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "metric": "ns/op", + "baseline": 8323, + "current": 10071, + "delta": 1748, + "deltaPct": 21.002042532740596, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32-20", + "metric": "ns/op", + "baseline": 271.6, + "current": 214.7, + "delta": -56.900000000000034, + "deltaPct": -20.949926362297507, + "direction": "improved" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkMarshalManifestJSON-20", + "metric": "ns/op", + "baseline": 883.1, + "current": 700.4, + "delta": -182.70000000000005, + "deltaPct": -20.688483750424645, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout", + "metric": "ns/op", + "baseline": 223.4, + "current": 269.6, + "delta": 46.20000000000002, + "deltaPct": 20.680393912265004, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32", + "metric": "ns/op", + "baseline": 40758, + "current": 49053, + "delta": 8295, + "deltaPct": 20.351832769026938, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "metric": "ns/op", + "baseline": 448.1, + "current": 357.6, + "delta": -90.5, + "deltaPct": -20.196384735550097, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString", + "metric": "ns/op", + "baseline": 564.4, + "current": 674.9, + "delta": 110.5, + "deltaPct": 19.578313253012052, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringPublicSSRSurface-20", + "metric": "ns/op", + "baseline": 6086, + "current": 4929, + "delta": -1157, + "deltaPct": -19.010844561288202, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer-20", + "metric": "ns/op", + "baseline": 11.11, + "current": 9.008, + "delta": -2.1020000000000003, + "deltaPct": -18.919891989198923, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "metric": "ns/op", + "baseline": 7985, + "current": 6480, + "delta": -1505, + "deltaPct": -18.847839699436445, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting-20", + "metric": "ns/op", + "baseline": 36.72, + "current": 29.82, + "delta": -6.899999999999999, + "deltaPct": -18.79084967320261, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTextShim", + "metric": "ns/op", + "baseline": 0.5529, + "current": 0.6564, + "delta": 0.10350000000000004, + "deltaPct": 18.71947911014651, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout-20", + "metric": "ns/op", + "baseline": 18.08, + "current": 14.72, + "delta": -3.3599999999999977, + "deltaPct": -18.584070796460168, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "metric": "ns/op", + "baseline": 22668, + "current": 18650, + "delta": -4018, + "deltaPct": -17.72542791600494, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse", + "metric": "ns/op", + "baseline": 34736, + "current": 40888, + "delta": 6152, + "deltaPct": 17.710732381391065, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals-20", + "metric": "ns/op", + "baseline": 0.1384, + "current": 0.114, + "delta": -0.02439999999999999, + "deltaPct": -17.6300578034682, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead-20", + "metric": "ns/op", + "baseline": 0.1349, + "current": 0.1112, + "delta": -0.0237, + "deltaPct": -17.568569310600445, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState", + "metric": "ns/op", + "baseline": 1794, + "current": 2105, + "delta": 311, + "deltaPct": 17.3355629877369, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalUnmarshalSnapshotJSON", + "metric": "ns/op", + "baseline": 12212, + "current": 14264, + "delta": 2052, + "deltaPct": 16.803144448083852, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16", + "metric": "ns/op", + "baseline": 31479, + "current": 26206, + "delta": -5273, + "deltaPct": -16.75084977286445, + "direction": "improved" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "metric": "ns/op", + "baseline": 5375, + "current": 4478, + "delta": -897, + "deltaPct": -16.688372093023258, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable", + "metric": "ns/op", + "baseline": 180.1, + "current": 209.9, + "delta": 29.80000000000001, + "deltaPct": 16.546363131593566, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt", + "metric": "ns/op", + "baseline": 9.104, + "current": 10.61, + "delta": 1.5060000000000002, + "deltaPct": 16.54217926186292, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkNormalizeLocaleMicro-20", + "metric": "ns/op", + "baseline": 385.9, + "current": 323.7, + "delta": -62.19999999999999, + "deltaPct": -16.11816532780513, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals", + "metric": "ns/op", + "baseline": 0.6957, + "current": 0.8077, + "delta": 0.11199999999999999, + "deltaPct": 16.098893201092423, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4", + "metric": "ns/op", + "baseline": 1572, + "current": 1320, + "delta": -252, + "deltaPct": -16.030534351145036, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting", + "metric": "ns/op", + "baseline": 87.21, + "current": 100.9, + "delta": 13.690000000000012, + "deltaPct": 15.697741084738004, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap", + "metric": "ns/op", + "baseline": 511.9, + "current": 592.2, + "delta": 80.30000000000007, + "deltaPct": 15.686657550302808, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy", + "metric": "ns/op", + "baseline": 0.6319, + "current": 0.534, + "delta": -0.09789999999999999, + "deltaPct": -15.492957746478872, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkUnmarshalSnapshotJSONMicro", + "metric": "ns/op", + "baseline": 8310, + "current": 7052, + "delta": -1258, + "deltaPct": -15.138387484957882, + "direction": "improved" + }, + { + "lane": "native", + "package": "./testkit/ssr", + "benchmark": "BenchmarkNormalizeStaticRoutePathMicro-20", + "metric": "ns/op", + "baseline": 4.741, + "current": 5.447, + "delta": 0.7060000000000004, + "deltaPct": 14.89137312803207, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren", + "metric": "ns/op", + "baseline": 1707, + "current": 1453, + "delta": -254, + "deltaPct": -14.879906268306971, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps", + "metric": "ns/op", + "baseline": 264.8, + "current": 304.2, + "delta": 39.39999999999998, + "deltaPct": 14.879154078549838, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "metric": "ns/op", + "baseline": 529.9, + "current": 451.8, + "delta": -78.09999999999997, + "deltaPct": -14.738629930175499, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate", + "metric": "ns/op", + "baseline": 2195615, + "current": 2516709, + "delta": 321094, + "deltaPct": 14.624330768372415, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI", + "metric": "ns/op", + "baseline": 95.82, + "current": 109.8, + "delta": 13.980000000000004, + "deltaPct": 14.589855979962435, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "metric": "ns/op", + "baseline": 3784, + "current": 3234, + "delta": -550, + "deltaPct": -14.534883720930234, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation", + "metric": "ns/op", + "baseline": 0.6219, + "current": 0.5322, + "delta": -0.0897, + "deltaPct": -14.423540762180414, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset-20", + "metric": "ns/op", + "baseline": 388.1, + "current": 441.9, + "delta": 53.799999999999955, + "deltaPct": 13.862406596238069, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender-20", + "metric": "ns/op", + "baseline": 67.41, + "current": 58.29, + "delta": -9.119999999999997, + "deltaPct": -13.529149977748107, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState-20", + "metric": "ns/op", + "baseline": 461.3, + "current": 399.2, + "delta": -62.10000000000002, + "deltaPct": -13.461955343594195, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64", + "metric": "ns/op", + "baseline": 5953, + "current": 6745, + "delta": 792, + "deltaPct": 13.304216361498405, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./testkit/render", + "benchmark": "BenchmarkNewResourceControllerMicro-20", + "metric": "ns/op", + "baseline": 53.15, + "current": 46.08, + "delta": -7.07, + "deltaPct": -13.301975540921921, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate-20", + "metric": "ns/op", + "baseline": 196.3, + "current": 170.4, + "delta": -25.900000000000006, + "deltaPct": -13.194090677534387, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkMergeResolvedMutation", + "metric": "ns/op", + "baseline": 1800, + "current": 2033, + "delta": 233, + "deltaPct": 12.944444444444445, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKey", + "metric": "ns/op", + "baseline": 2131, + "current": 1861, + "delta": -270, + "deltaPct": -12.670107930549038, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo", + "metric": "ns/op", + "baseline": 9658, + "current": 8436, + "delta": -1222, + "deltaPct": -12.652723131083041, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps-20", + "metric": "B/op", + "baseline": 115, + "current": 101, + "delta": -14, + "deltaPct": -12.173913043478262, + "direction": "improved" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlan-20", + "metric": "ns/op", + "baseline": 2594, + "current": 2288, + "delta": -306, + "deltaPct": -11.7964533538936, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath", + "metric": "ns/op", + "baseline": 10.15, + "current": 8.963, + "delta": -1.1870000000000012, + "deltaPct": -11.694581280788189, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable-20", + "metric": "ns/op", + "baseline": 33.77, + "current": 37.67, + "delta": 3.8999999999999986, + "deltaPct": 11.548711874444768, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender", + "metric": "ns/op", + "baseline": 2254, + "current": 2512, + "delta": 258, + "deltaPct": 11.446317657497781, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps-20", + "metric": "ns/op", + "baseline": 57.94, + "current": 51.47, + "delta": -6.469999999999999, + "deltaPct": -11.166724197445632, + "direction": "improved" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePath-20", + "metric": "ns/op", + "baseline": 4.391, + "current": 3.924, + "delta": -0.4670000000000001, + "deltaPct": -10.635390571623777, + "direction": "improved" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapBinary-20", + "metric": "ns/op", + "baseline": 1373, + "current": 1227, + "delta": -146, + "deltaPct": -10.633648943918427, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64-20", + "metric": "ns/op", + "baseline": 2089, + "current": 1869, + "delta": -220, + "deltaPct": -10.531354715174725, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap", + "metric": "B/op", + "baseline": 134, + "current": 120, + "delta": -14, + "deltaPct": -10.44776119402985, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset-20", + "metric": "ns/op", + "baseline": 372.5, + "current": 334, + "delta": -38.5, + "deltaPct": -10.335570469798657, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "metric": "ns/op", + "baseline": 48265, + "current": 53190, + "delta": 4925, + "deltaPct": 10.204081632653061, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32-20", + "metric": "ns/op", + "baseline": 12158, + "current": 10937, + "delta": -1221, + "deltaPct": -10.042770192465866, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8", + "metric": "ns/op", + "baseline": 5804, + "current": 6383, + "delta": 579, + "deltaPct": 9.975878704341833, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderJSONLD-20", + "metric": "ns/op", + "baseline": 11506, + "current": 10408, + "delta": -1098, + "deltaPct": -9.542847210151226, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubRefetch-20", + "metric": "ns/op", + "baseline": 0.9643, + "current": 1.052, + "delta": 0.0877, + "deltaPct": 9.094680078813647, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable-20", + "metric": "B/op", + "baseline": 88, + "current": 96, + "delta": 8, + "deltaPct": 9.090909090909092, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkTagDivWithCommonProps-20", + "metric": "ns/op", + "baseline": 829.1, + "current": 753.9, + "delta": -75.20000000000005, + "deltaPct": -9.07007598600893, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren-20", + "metric": "ns/op", + "baseline": 488.6, + "current": 445.3, + "delta": -43.30000000000001, + "deltaPct": -8.862054850593534, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender", + "metric": "ns/op", + "baseline": 377.5, + "current": 344.1, + "delta": -33.39999999999998, + "deltaPct": -8.847682119205293, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16-20", + "metric": "ns/op", + "baseline": 4363, + "current": 3977, + "delta": -386, + "deltaPct": -8.847123538849415, + "direction": "improved" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringMicro-20", + "metric": "ns/op", + "baseline": 132.8, + "current": 144.4, + "delta": 11.599999999999994, + "deltaPct": 8.73493975903614, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector", + "metric": "ns/op", + "baseline": 35354, + "current": 32331, + "delta": -3023, + "deltaPct": -8.550659048481076, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8", + "metric": "ns/op", + "baseline": 6074, + "current": 5556, + "delta": -518, + "deltaPct": -8.528152782351004, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockSchedulerFlushAll-20", + "metric": "ns/op", + "baseline": 1740, + "current": 1887, + "delta": 147, + "deltaPct": 8.448275862068966, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender", + "metric": "B/op", + "baseline": 95, + "current": 87, + "delta": -8, + "deltaPct": -8.421052631578947, + "direction": "improved" + }, + { + "lane": "native", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro-20", + "metric": "ns/op", + "baseline": 657.5, + "current": 603.3, + "delta": -54.200000000000045, + "deltaPct": -8.24334600760457, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer-20", + "metric": "ns/op", + "baseline": 53.64, + "current": 49.24, + "delta": -4.399999999999999, + "deltaPct": -8.202833706189407, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable-20", + "metric": "B/op", + "baseline": 98, + "current": 90, + "delta": -8, + "deltaPct": -8.16326530612245, + "direction": "improved" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "metric": "ns/op", + "baseline": 56351, + "current": 60927, + "delta": 4576, + "deltaPct": 8.120530247910418, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetTarget", + "metric": "ns/op", + "baseline": 2070, + "current": 1903, + "delta": -167, + "deltaPct": -8.067632850241546, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "metric": "ns/op", + "baseline": 3.994, + "current": 4.311, + "delta": 0.3169999999999997, + "deltaPct": 7.936905358037048, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "metric": "ns/op", + "baseline": 54584, + "current": 58799, + "delta": 4215, + "deltaPct": 7.722043089550051, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI-20", + "metric": "ns/op", + "baseline": 35.51, + "current": 32.81, + "delta": -2.6999999999999957, + "deltaPct": -7.603491974091793, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelector", + "metric": "ns/op", + "baseline": 37336, + "current": 34559, + "delta": -2777, + "deltaPct": -7.43786158131562, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse-20", + "metric": "ns/op", + "baseline": 427486, + "current": 396136, + "delta": -31350, + "deltaPct": -7.3335734971437665, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation-20", + "metric": "ns/op", + "baseline": 12.29, + "current": 11.4, + "delta": -0.8899999999999988, + "deltaPct": -7.241659886086239, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8-20", + "metric": "ns/op", + "baseline": 1290, + "current": 1197, + "delta": -93, + "deltaPct": -7.209302325581396, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap-20", + "metric": "ns/op", + "baseline": 79.42, + "current": 73.7, + "delta": -5.719999999999999, + "deltaPct": -7.202216066481992, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer", + "metric": "ns/op", + "baseline": 101.5, + "current": 108.8, + "delta": 7.299999999999997, + "deltaPct": 7.192118226600982, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString", + "metric": "ns/op", + "baseline": 15.13, + "current": 14.06, + "delta": -1.0700000000000003, + "deltaPct": -7.072042300066094, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender-20", + "metric": "B/op", + "baseline": 99, + "current": 92, + "delta": -7, + "deltaPct": -7.07070707070707, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "metric": "ns/op", + "baseline": 1267, + "current": 1179, + "delta": -88, + "deltaPct": -6.945540647198106, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead", + "metric": "ns/op", + "baseline": 0.6073, + "current": 0.5656, + "delta": -0.04169999999999996, + "deltaPct": -6.866458093199402, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren", + "metric": "ns/op", + "baseline": 1347, + "current": 1255, + "delta": -92, + "deltaPct": -6.829992576095026, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom", + "metric": "ns/op", + "baseline": 41.84, + "current": 39.02, + "delta": -2.8200000000000003, + "deltaPct": -6.739961759082218, + "direction": "improved" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkBundleTranslate-20", + "metric": "ns/op", + "baseline": 3579, + "current": 3338, + "delta": -241, + "deltaPct": -6.733724504051411, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4-20", + "metric": "ns/op", + "baseline": 552, + "current": 588.9, + "delta": 36.89999999999998, + "deltaPct": 6.684782608695648, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReport-20", + "metric": "ns/op", + "baseline": 10556, + "current": 11260, + "delta": 704, + "deltaPct": 6.6691928760894275, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement", + "metric": "ns/op", + "baseline": 54.1, + "current": 57.54, + "delta": 3.4399999999999977, + "deltaPct": 6.358595194085023, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkModuleCall", + "metric": "ns/op", + "baseline": 12626, + "current": 11827, + "delta": -799, + "deltaPct": -6.328211626801837, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState-20", + "metric": "ns/op", + "baseline": 10405, + "current": 9748, + "delta": -657, + "deltaPct": -6.314271984622777, + "direction": "improved" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsSmall-20", + "metric": "ns/op", + "baseline": 76.56, + "current": 71.79, + "delta": -4.769999999999996, + "deltaPct": -6.230407523510966, + "direction": "improved" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "metric": "ns/op", + "baseline": 1887, + "current": 1774, + "delta": -113, + "deltaPct": -5.988341282458929, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "metric": "ns/op", + "baseline": 827.8, + "current": 877, + "delta": 49.200000000000045, + "deltaPct": 5.943464604977054, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate", + "metric": "ns/op", + "baseline": 1130, + "current": 1063, + "delta": -67, + "deltaPct": -5.929203539823009, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo-20", + "metric": "ns/op", + "baseline": 1860, + "current": 1751, + "delta": -109, + "deltaPct": -5.860215053763441, + "direction": "improved" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderBootstrapReferenceScript-20", + "metric": "ns/op", + "baseline": 2086, + "current": 2207, + "delta": 121, + "deltaPct": 5.8005752636625125, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16-20", + "metric": "ns/op", + "baseline": 5024, + "current": 5314, + "delta": 290, + "deltaPct": 5.772292993630574, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256-20", + "metric": "ns/op", + "baseline": 312.8, + "current": 294.8, + "delta": -18, + "deltaPct": -5.754475703324808, + "direction": "improved" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapJSON-20", + "metric": "ns/op", + "baseline": 5323, + "current": 5019, + "delta": -304, + "deltaPct": -5.711065188803306, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "metric": "ns/op", + "baseline": 52486, + "current": 49607, + "delta": -2879, + "deltaPct": -5.485272263079678, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "metric": "ns/op", + "baseline": 803.4, + "current": 759.6, + "delta": -43.799999999999955, + "deltaPct": -5.451829723674378, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16", + "metric": "ns/op", + "baseline": 18998, + "current": 17975, + "delta": -1023, + "deltaPct": -5.384777344983682, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps-20", + "metric": "ns/op", + "baseline": 64.47, + "current": 61.01, + "delta": -3.460000000000001, + "deltaPct": -5.366837288661394, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState", + "metric": "ns/op", + "baseline": 542.1, + "current": 513.1, + "delta": -29, + "deltaPct": -5.349566500645637, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionStringInvoke", + "metric": "ns/op", + "baseline": 11386, + "current": 10787, + "delta": -599, + "deltaPct": -5.26084665378535, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16-20", + "metric": "ns/op", + "baseline": 4254, + "current": 4472, + "delta": 218, + "deltaPct": 5.124588622472967, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkCustomElementWithAttributesAndProperties-20", + "metric": "ns/op", + "baseline": 652.8, + "current": 686.2, + "delta": 33.40000000000009, + "deltaPct": 5.116421568627465, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsMicro-20", + "metric": "ns/op", + "baseline": 62.57, + "current": 59.38, + "delta": -3.1899999999999977, + "deltaPct": -5.098289915294866, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationIDMicro", + "metric": "ns/op", + "baseline": 679.4, + "current": 645.1, + "delta": -34.299999999999955, + "deltaPct": -5.048572269649684, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "metric": "ns/op", + "baseline": 6620, + "current": 6288, + "delta": -332, + "deltaPct": -5.015105740181268, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter", + "metric": "ns/op", + "baseline": 48.56, + "current": 46.19, + "delta": -2.3700000000000045, + "deltaPct": -4.8805601317957255, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkLocalStorageGetItem", + "metric": "ns/op", + "baseline": 14827, + "current": 14119, + "delta": -708, + "deltaPct": -4.775072502866393, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkEvaluateNavigationNestedLayouts", + "metric": "ns/op", + "baseline": 32359, + "current": 30824, + "delta": -1535, + "deltaPct": -4.7436570969436636, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable-20", + "metric": "ns/op", + "baseline": 42.02, + "current": 44, + "delta": 1.9799999999999969, + "deltaPct": 4.712041884816746, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkCurrentNestedLayoutRoute", + "metric": "ns/op", + "baseline": 1192520, + "current": 1136635, + "delta": -55885, + "deltaPct": -4.6862945694831115, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps", + "metric": "ns/op", + "baseline": 336, + "current": 351.6, + "delta": 15.600000000000023, + "deltaPct": 4.64285714285715, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkSnapshotSelect", + "metric": "ns/op", + "baseline": 247.8, + "current": 259.2, + "delta": 11.399999999999977, + "deltaPct": 4.600484261501201, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer", + "metric": "ns/op", + "baseline": 196.2, + "current": 187.3, + "delta": -8.899999999999977, + "deltaPct": -4.536187563710488, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer", + "metric": "ns/op", + "baseline": 168, + "current": 160.5, + "delta": -7.5, + "deltaPct": -4.464285714285714, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventIsChecked", + "metric": "ns/op", + "baseline": 1995, + "current": 1907, + "delta": -88, + "deltaPct": -4.4110275689223055, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable", + "metric": "B/op", + "baseline": 91, + "current": 87, + "delta": -4, + "deltaPct": -4.395604395604396, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct", + "metric": "ns/op", + "baseline": 11092, + "current": 11579, + "delta": 487, + "deltaPct": 4.390551749008295, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout", + "metric": "B/op", + "baseline": 46, + "current": 48, + "delta": 2, + "deltaPct": 4.3478260869565215, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePathMicro-20", + "metric": "ns/op", + "baseline": 4.615, + "current": 4.418, + "delta": -0.19700000000000006, + "deltaPct": -4.268689057421453, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout-20", + "metric": "B/op", + "baseline": 47, + "current": 45, + "delta": -2, + "deltaPct": -4.25531914893617, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "metric": "ns/op", + "baseline": 71065, + "current": 74074, + "delta": 3009, + "deltaPct": 4.2341518328291, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback-20", + "metric": "ns/op", + "baseline": 9271, + "current": 8880, + "delta": -391, + "deltaPct": -4.21745227052098, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse-20", + "metric": "ns/op", + "baseline": 8076, + "current": 7738, + "delta": -338, + "deltaPct": -4.1852402179296675, + "direction": "improved" + }, + { + "lane": "native", + "package": "./testkit/router", + "benchmark": "BenchmarkFixtureStubMethodsMicro-20", + "metric": "ns/op", + "baseline": 0.1151, + "current": 0.1199, + "delta": 0.004800000000000013, + "deltaPct": 4.170286707211132, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16-20", + "metric": "ns/op", + "baseline": 355.1, + "current": 369.7, + "delta": 14.599999999999966, + "deltaPct": 4.1115178822866705, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "metric": "ns/op", + "baseline": 110022, + "current": 114382, + "delta": 4360, + "deltaPct": 3.9628437948773882, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap-20", + "metric": "B/op", + "baseline": 128, + "current": 133, + "delta": 5, + "deltaPct": 3.90625, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "metric": "ns/op", + "baseline": 47508, + "current": 45690, + "delta": -1818, + "deltaPct": -3.826723920181864, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256", + "metric": "ns/op", + "baseline": 707.4, + "current": 733.8, + "delta": 26.399999999999977, + "deltaPct": 3.731976251060217, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubGetter-20", + "metric": "ns/op", + "baseline": 1.479, + "current": 1.424, + "delta": -0.05500000000000016, + "deltaPct": -3.7187288708586985, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16", + "metric": "ns/op", + "baseline": 5322, + "current": 5519, + "delta": 197, + "deltaPct": 3.7016159338594514, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKeyCode", + "metric": "ns/op", + "baseline": 267, + "current": 276.7, + "delta": 9.699999999999989, + "deltaPct": 3.632958801498123, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetPropertyString", + "metric": "ns/op", + "baseline": 1863, + "current": 1929, + "delta": 66, + "deltaPct": 3.542673107890499, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "metric": "ns/op", + "baseline": 129740, + "current": 134323, + "delta": 4583, + "deltaPct": 3.5324495144134422, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkResolveRouteStackNestedLayout", + "metric": "ns/op", + "baseline": 3384, + "current": 3503, + "delta": 119, + "deltaPct": 3.5165484633569744, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationID", + "metric": "ns/op", + "baseline": 441, + "current": 425.6, + "delta": -15.399999999999977, + "deltaPct": -3.4920634920634868, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalSnapshotJSONMicro", + "metric": "ns/op", + "baseline": 3872, + "current": 4002, + "delta": 130, + "deltaPct": 3.3574380165289255, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkMergeDocumentMicro-20", + "metric": "ns/op", + "baseline": 79.79, + "current": 77.13, + "delta": -2.660000000000011, + "deltaPct": -3.3337510966286636, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable", + "metric": "ns/op", + "baseline": 178.3, + "current": 172.4, + "delta": -5.900000000000006, + "deltaPct": -3.3090297251822802, + "direction": "improved" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkCompareSnapshotsMicro-20", + "metric": "ns/op", + "baseline": 17396, + "current": 17959, + "delta": 563, + "deltaPct": 3.2363761784318235, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps", + "metric": "B/op", + "baseline": 95, + "current": 98, + "delta": 3, + "deltaPct": 3.1578947368421053, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro", + "metric": "ns/op", + "baseline": 2733, + "current": 2812, + "delta": 79, + "deltaPct": 2.890596414196853, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "metric": "ns/op", + "baseline": 40427, + "current": 39267, + "delta": -1160, + "deltaPct": -2.8693694807925394, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate", + "metric": "ns/op", + "baseline": 538.3, + "current": 523.5, + "delta": -14.799999999999955, + "deltaPct": -2.749396247445654, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps-20", + "metric": "B/op", + "baseline": 110, + "current": 113, + "delta": 3, + "deltaPct": 2.727272727272727, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate-20", + "metric": "ns/op", + "baseline": 390.2, + "current": 379.6, + "delta": -10.599999999999966, + "deltaPct": -2.7165556125063985, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "metric": "ns/op", + "baseline": 206059, + "current": 211598, + "delta": 5539, + "deltaPct": 2.688065068742447, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderToString-20", + "metric": "ns/op", + "baseline": 35495, + "current": 36431, + "delta": 936, + "deltaPct": 2.6369911255106353, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender-20", + "metric": "ns/op", + "baseline": 657.8, + "current": 640.5, + "delta": -17.299999999999955, + "deltaPct": -2.629978716935232, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives-20", + "metric": "ns/op", + "baseline": 8.232, + "current": 8.448, + "delta": 0.21600000000000108, + "deltaPct": 2.6239067055393717, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnabled-20", + "metric": "ns/op", + "baseline": 0.2049, + "current": 0.1996, + "delta": -0.005299999999999999, + "deltaPct": -2.586627623230844, + "direction": "improved" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchRefetchUnavailable", + "metric": "B/op", + "baseline": 80, + "current": 82, + "delta": 2, + "deltaPct": 2.5, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkReportFormatted-20", + "metric": "ns/op", + "baseline": 712.4, + "current": 729.7, + "delta": 17.300000000000068, + "deltaPct": 2.4284110050533507, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkTagWithMixedArgs-20", + "metric": "ns/op", + "baseline": 1751, + "current": 1789, + "delta": 38, + "deltaPct": 2.1701884637350086, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy", + "metric": "ns/op", + "baseline": 1291, + "current": 1319, + "delta": 28, + "deltaPct": 2.168861347792409, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycleMicro-20", + "metric": "ns/op", + "baseline": 0.1126, + "current": 0.1102, + "delta": -0.0023999999999999994, + "deltaPct": -2.131438721136767, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4-20", + "metric": "ns/op", + "baseline": 520.7, + "current": 531.4, + "delta": 10.699999999999932, + "deltaPct": 2.054926061071621, + "direction": "regressed" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycle-20", + "metric": "ns/op", + "baseline": 0.2306, + "current": 0.2259, + "delta": -0.00470000000000001, + "deltaPct": -2.038161318300091, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom-20", + "metric": "ns/op", + "baseline": 13.29, + "current": 13.02, + "delta": -0.2699999999999996, + "deltaPct": -2.0316027088036086, + "direction": "improved" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter-20", + "metric": "ns/op", + "baseline": 13.82, + "current": 14.1, + "delta": 0.27999999999999936, + "deltaPct": 2.026049204052094, + "direction": "regressed" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps", + "metric": "B/op", + "baseline": 102, + "current": 104, + "delta": 2, + "deltaPct": 1.9607843137254901, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps-20", + "metric": "B/op", + "baseline": 103, + "current": 101, + "delta": -2, + "deltaPct": -1.9417475728155338, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256-20", + "metric": "ns/op", + "baseline": 193.8, + "current": 190.2, + "delta": -3.6000000000000227, + "deltaPct": -1.8575851393188971, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines", + "metric": "ns/op", + "baseline": 0.533, + "current": 0.5231, + "delta": -0.00990000000000002, + "deltaPct": -1.8574108818011292, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "metric": "ns/op", + "baseline": 21, + "current": 20.61, + "delta": -0.39000000000000057, + "deltaPct": -1.8571428571428599, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "metric": "ns/op", + "baseline": 177.9, + "current": 174.8, + "delta": -3.0999999999999943, + "deltaPct": -1.7425519955030884, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterBatchAppend16", + "metric": "ns/op", + "baseline": 336351, + "current": 342044, + "delta": 5693, + "deltaPct": 1.692577099518063, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterAppendChild", + "metric": "ns/op", + "baseline": 46619, + "current": 47405, + "delta": 786, + "deltaPct": 1.6860078508762522, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkLoggerScope-20", + "metric": "ns/op", + "baseline": 0.4884, + "current": 0.4965, + "delta": 0.008099999999999996, + "deltaPct": 1.6584766584766577, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "metric": "ns/op", + "baseline": 972.8, + "current": 988.9, + "delta": 16.100000000000023, + "deltaPct": 1.6550164473684232, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkNewHostWithCapabilities-20", + "metric": "ns/op", + "baseline": 177, + "current": 174.1, + "delta": -2.9000000000000057, + "deltaPct": -1.6384180790960483, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetValue", + "metric": "ns/op", + "baseline": 3491, + "current": 3434, + "delta": -57, + "deltaPct": -1.632769979948439, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportState-20", + "metric": "ns/op", + "baseline": 16.44, + "current": 16.7, + "delta": 0.259999999999998, + "deltaPct": 1.5815085158150728, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSnapshotNowMicro-20", + "metric": "ns/op", + "baseline": 28.55, + "current": 28.14, + "delta": -0.41000000000000014, + "deltaPct": -1.4360770577933455, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "metric": "B/op", + "baseline": 33268, + "current": 33724, + "delta": 456, + "deltaPct": 1.3706865456294337, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath-20", + "metric": "ns/op", + "baseline": 7.063, + "current": 7.159, + "delta": 0.09600000000000009, + "deltaPct": 1.3591958091462564, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "metric": "ns/op", + "baseline": 19.36, + "current": 19.1, + "delta": -0.259999999999998, + "deltaPct": -1.3429752066115601, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString-20", + "metric": "ns/op", + "baseline": 161.4, + "current": 159.3, + "delta": -2.0999999999999943, + "deltaPct": -1.3011152416356841, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGlobalInit", + "metric": "B/op", + "baseline": 1156, + "current": 1141, + "delta": -15, + "deltaPct": -1.2975778546712802, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "metric": "ns/op", + "baseline": 21.71, + "current": 21.98, + "delta": 0.2699999999999996, + "deltaPct": 1.2436665131275888, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives", + "metric": "ns/op", + "baseline": 38.11, + "current": 37.64, + "delta": -0.46999999999999886, + "deltaPct": -1.233272107058512, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable", + "metric": "B/op", + "baseline": 85, + "current": 84, + "delta": -1, + "deltaPct": -1.1764705882352942, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256", + "metric": "ns/op", + "baseline": 308.6, + "current": 312.2, + "delta": 3.599999999999966, + "deltaPct": 1.1665586519766578, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkBuildTargetJSONBootstrap-20", + "metric": "ns/op", + "baseline": 400.3, + "current": 395.8, + "delta": -4.5, + "deltaPct": -1.1241568823382464, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "metric": "ns/op", + "baseline": 478768, + "current": 483564, + "delta": 4796, + "deltaPct": 1.0017377936704208, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/hooks", + "benchmark": "BenchmarkHarnessStubMethodsMicro-20", + "metric": "ns/op", + "baseline": 0.1145, + "current": 0.1156, + "delta": 0.0010999999999999899, + "deltaPct": 0.9606986899563229, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState-20", + "metric": "ns/op", + "baseline": 178.6, + "current": 176.9, + "delta": -1.6999999999999886, + "deltaPct": -0.9518477043672949, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct-20", + "metric": "ns/op", + "baseline": 1999, + "current": 1980, + "delta": -19, + "deltaPct": -0.9504752376188095, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkBuild-20", + "metric": "ns/op", + "baseline": 9526, + "current": 9609, + "delta": 83, + "deltaPct": 0.871299601091749, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250", + "metric": "B/op", + "baseline": 231728, + "current": 229709, + "delta": -2019, + "deltaPct": -0.8712801215217841, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReportMicro-20", + "metric": "ns/op", + "baseline": 12345, + "current": 12243, + "delta": -102, + "deltaPct": -0.8262454434993926, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16-20", + "metric": "ns/op", + "baseline": 233.4, + "current": 235.3, + "delta": 1.9000000000000057, + "deltaPct": 0.8140531276778088, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterGetElementById", + "metric": "ns/op", + "baseline": 33249, + "current": 33020, + "delta": -229, + "deltaPct": -0.6887425185719871, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "metric": "B/op", + "baseline": 42327, + "current": 42595, + "delta": 268, + "deltaPct": 0.6331655917026956, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "metric": "B/op", + "baseline": 33225, + "current": 33430, + "delta": 205, + "deltaPct": 0.617005267118134, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "metric": "B/op", + "baseline": 35822, + "current": 36035, + "delta": 213, + "deltaPct": 0.5946066662944559, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "metric": "B/op", + "baseline": 41758, + "current": 41535, + "delta": -223, + "deltaPct": -0.5340294075386752, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubInit-20", + "metric": "ns/op", + "baseline": 0.1146, + "current": 0.114, + "delta": -0.0005999999999999894, + "deltaPct": -0.5235602094240746, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "metric": "B/op", + "baseline": 42588, + "current": 42768, + "delta": 180, + "deltaPct": 0.422654268808115, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro-20", + "metric": "ns/op", + "baseline": 73.56, + "current": 73.87, + "delta": 0.3100000000000023, + "deltaPct": 0.42142468733007377, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteMicro-20", + "metric": "ns/op", + "baseline": 19.95, + "current": 19.87, + "delta": -0.0799999999999983, + "deltaPct": -0.40100250626565564, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector-20", + "metric": "B/op", + "baseline": 7826, + "current": 7798, + "delta": -28, + "deltaPct": -0.35778175313059035, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector", + "metric": "B/op", + "baseline": 7770, + "current": 7796, + "delta": 26, + "deltaPct": 0.33462033462033464, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "metric": "B/op", + "baseline": 33649, + "current": 33755, + "delta": 106, + "deltaPct": 0.315016790989331, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "metric": "B/op", + "baseline": 334, + "current": 333, + "delta": -1, + "deltaPct": -0.29940119760479045, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkWriteHTTPError-20", + "metric": "ns/op", + "baseline": 31411, + "current": 31498, + "delta": 87, + "deltaPct": 0.2769730349240712, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkCurrentNestedLayoutRoute", + "metric": "B/op", + "baseline": 12258, + "current": 12228, + "delta": -30, + "deltaPct": -0.24473813020068524, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250-20", + "metric": "B/op", + "baseline": 239901, + "current": 240468, + "delta": 567, + "deltaPct": 0.23634749334100316, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "metric": "B/op", + "baseline": 1351, + "current": 1354, + "delta": 3, + "deltaPct": 0.22205773501110287, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "metric": "B/op", + "baseline": 34977, + "current": 35052, + "delta": 75, + "deltaPct": 0.2144266232095377, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookStateRerenderMicroWasm", + "metric": "B/op", + "baseline": 68227, + "current": 68085, + "delta": -142, + "deltaPct": -0.20812874668386416, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkResolveMutationQueueOptions", + "metric": "ns/op", + "baseline": 28.59, + "current": 28.64, + "delta": 0.05000000000000071, + "deltaPct": 0.1748863238894743, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "metric": "B/op", + "baseline": 37332, + "current": 37288, + "delta": -44, + "deltaPct": -0.11786135219114968, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "metric": "B/op", + "baseline": 32960, + "current": 32926, + "delta": -34, + "deltaPct": -0.10315533980582525, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportStateMicro-20", + "metric": "ns/op", + "baseline": 8.771, + "current": 8.78, + "delta": 0.008999999999998565, + "deltaPct": 0.10261087675291945, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState", + "metric": "B/op", + "baseline": 33993, + "current": 33959, + "delta": -34, + "deltaPct": -0.1000205924749213, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "metric": "B/op", + "baseline": 33310, + "current": 33277, + "delta": -33, + "deltaPct": -0.09906934854398079, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "metric": "B/op", + "baseline": 32883, + "current": 32851, + "delta": -32, + "deltaPct": -0.09731472189277134, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender", + "metric": "B/op", + "baseline": 33964, + "current": 33995, + "delta": 31, + "deltaPct": 0.09127311270757273, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState-20", + "metric": "B/op", + "baseline": 34140, + "current": 34162, + "delta": 22, + "deltaPct": 0.06444053895723491, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector-20", + "metric": "ns/op", + "baseline": 4996, + "current": 4993, + "delta": -3, + "deltaPct": -0.06004803843074459, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250-20", + "metric": "allocs/op", + "baseline": 1788, + "current": 1787, + "delta": -1, + "deltaPct": -0.05592841163310962, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTransitionListRefresh250", + "metric": "allocs/op", + "baseline": 1788, + "current": 1789, + "delta": 1, + "deltaPct": 0.05592841163310962, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender-20", + "metric": "B/op", + "baseline": 34149, + "current": 34166, + "delta": 17, + "deltaPct": 0.0497818384140092, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "metric": "ns/op", + "baseline": 43.23, + "current": 43.25, + "delta": 0.020000000000003126, + "deltaPct": 0.04626416840158022, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "metric": "B/op", + "baseline": 41532, + "current": 41519, + "delta": -13, + "deltaPct": -0.03130116536646441, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "metric": "B/op", + "baseline": 35783, + "current": 35791, + "delta": 8, + "deltaPct": 0.0223569851605511, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16-20", + "metric": "B/op", + "baseline": 5666, + "current": 5667, + "delta": 1, + "deltaPct": 0.017649135192375574, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback-20", + "metric": "B/op", + "baseline": 9209, + "current": 9208, + "delta": -1, + "deltaPct": -0.01085894233901618, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchRefetchUnavailable", + "metric": "ns/op", + "baseline": 15527951, + "current": 15529536, + "delta": 1585, + "deltaPct": 0.01020739954679146, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "metric": "B/op", + "baseline": 35022, + "current": 35019, + "delta": -3, + "deltaPct": -0.008566044200788077, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse-20", + "metric": "B/op", + "baseline": 430795, + "current": 430818, + "delta": 23, + "deltaPct": 0.005338966329692777, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "metric": "B/op", + "baseline": 451306, + "current": 451299, + "delta": -7, + "deltaPct": -0.0015510540520179213, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse", + "metric": "B/op", + "baseline": 430011, + "current": 430012, + "delta": 1, + "deltaPct": 0.00023255219052535867, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkCompareSnapshotsMicro-20", + "metric": "B/op", + "baseline": 11554, + "current": 11554, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkCompareSnapshotsMicro-20", + "metric": "allocs/op", + "baseline": 46, + "current": 46, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkExportSupportDiagnosticBundleJSON-20", + "metric": "allocs/op", + "baseline": 110, + "current": 110, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSanitizeBugCaptureBundleForSupport-20", + "metric": "allocs/op", + "baseline": 97, + "current": 97, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSnapshotNowMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./devtools", + "benchmark": "BenchmarkSnapshotNowMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReport-20", + "metric": "B/op", + "baseline": 6494, + "current": 6494, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReport-20", + "metric": "allocs/op", + "baseline": 40, + "current": 40, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReportMicro-20", + "metric": "B/op", + "baseline": 6510, + "current": 6510, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkNewReportMicro-20", + "metric": "allocs/op", + "baseline": 42, + "current": 42, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkWriteHTTPError-20", + "metric": "B/op", + "baseline": 6443, + "current": 6443, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./diagnostics", + "benchmark": "BenchmarkWriteHTTPError-20", + "metric": "allocs/op", + "baseline": 41, + "current": 41, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkMergeDocumentMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkMergeDocumentMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderJSONLD-20", + "metric": "B/op", + "baseline": 9650, + "current": 9650, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderJSONLD-20", + "metric": "allocs/op", + "baseline": 45, + "current": 45, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderToString-20", + "metric": "B/op", + "baseline": 36999, + "current": 36999, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./head", + "benchmark": "BenchmarkRenderToString-20", + "metric": "allocs/op", + "baseline": 320, + "current": 320, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycle-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycle-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycleMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnableDisableCycleMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnabled-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./hotreload", + "benchmark": "BenchmarkEnabled-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkCustomElementWithAttributesAndProperties-20", + "metric": "B/op", + "baseline": 912, + "current": 912, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkCustomElementWithAttributesAndProperties-20", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkDivNodeConstructionMicro-20", + "metric": "B/op", + "baseline": 872, + "current": 872, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkDivNodeConstructionMicro-20", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkTagDivWithCommonProps-20", + "metric": "B/op", + "baseline": 1064, + "current": 1064, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html", + "benchmark": "BenchmarkTagDivWithCommonProps-20", + "metric": "allocs/op", + "baseline": 18, + "current": 18, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkClassNames-20", + "metric": "B/op", + "baseline": 336, + "current": 336, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkClassNames-20", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkTagWithMixedArgs-20", + "metric": "B/op", + "baseline": 4160, + "current": 4160, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./html/shorthand", + "benchmark": "BenchmarkTagWithMixedArgs-20", + "metric": "allocs/op", + "baseline": 29, + "current": 29, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkBundleTranslate-20", + "metric": "B/op", + "baseline": 3176, + "current": 3176, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkBundleTranslate-20", + "metric": "allocs/op", + "baseline": 46, + "current": 46, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkNormalizeLocaleMicro-20", + "metric": "B/op", + "baseline": 244, + "current": 244, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./i18n", + "benchmark": "BenchmarkNormalizeLocaleMicro-20", + "metric": "allocs/op", + "baseline": 4, + "current": 4, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkBuild-20", + "metric": "B/op", + "baseline": 6141, + "current": 6141, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkBuild-20", + "metric": "allocs/op", + "baseline": 35, + "current": 35, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkReportFormatted-20", + "metric": "B/op", + "baseline": 1801, + "current": 1801, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "benchmark": "BenchmarkReportFormatted-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-20", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockSchedulerFlushAll-20", + "metric": "B/op", + "baseline": 816, + "current": 816, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "benchmark": "BenchmarkMockSchedulerFlushAll-20", + "metric": "allocs/op", + "baseline": 27, + "current": 27, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting-20", + "metric": "B/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "metric": "B/op", + "baseline": 264, + "current": 264, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "metric": "B/op", + "baseline": 192, + "current": 192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8-20", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32-20", + "metric": "B/op", + "baseline": 21072, + "current": 21072, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32-20", + "metric": "allocs/op", + "baseline": 171, + "current": 171, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren-20", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren-20", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4-20", + "metric": "B/op", + "baseline": 744, + "current": 744, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4-20", + "metric": "allocs/op", + "baseline": 9, + "current": 9, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren-20", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren-20", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-20", + "metric": "allocs/op", + "baseline": 33, + "current": 33, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-20", + "metric": "allocs/op", + "baseline": 33, + "current": 33, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-20", + "metric": "allocs/op", + "baseline": 146, + "current": 146, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-20", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-20", + "metric": "allocs/op", + "baseline": 130, + "current": 130, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-20", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-20", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy-20", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy-20", + "metric": "ns/op", + "baseline": 468.9, + "current": 468.9, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate-20", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset-20", + "metric": "B/op", + "baseline": 444, + "current": 444, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset-20", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubGetter-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubGetter-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubInit-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubInit-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubRefetch-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchStubRefetch-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate-20", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset-20", + "metric": "B/op", + "baseline": 436, + "current": 436, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate-20", + "metric": "allocs/op", + "baseline": 5759, + "current": 5759, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse-20", + "metric": "allocs/op", + "baseline": 6020, + "current": 6020, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse-20", + "metric": "B/op", + "baseline": 8535, + "current": 8535, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse-20", + "metric": "allocs/op", + "baseline": 70, + "current": 70, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback-20", + "metric": "allocs/op", + "baseline": 83, + "current": 83, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet-20", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-20", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-20", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16-20", + "metric": "B/op", + "baseline": 5697, + "current": 5697, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16-20", + "metric": "allocs/op", + "baseline": 18, + "current": 18, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16-20", + "metric": "B/op", + "baseline": 5637, + "current": 5637, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16-20", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16-20", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender-20", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector-20", + "metric": "allocs/op", + "baseline": 55, + "current": 55, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState-20", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo-20", + "metric": "B/op", + "baseline": 3114, + "current": 3114, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo-20", + "metric": "allocs/op", + "baseline": 20, + "current": 20, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate-20", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32-20", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState-20", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender-20", + "metric": "B/op", + "baseline": 1120, + "current": 1120, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender-20", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4-20", + "metric": "B/op", + "baseline": 760, + "current": 760, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4-20", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct-20", + "metric": "B/op", + "baseline": 1137, + "current": 1137, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct-20", + "metric": "allocs/op", + "baseline": 29, + "current": 29, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString-20", + "metric": "B/op", + "baseline": 480, + "current": 480, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString-20", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsSmall-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkCloneFieldsSmall-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkLoggerScope-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./logging", + "benchmark": "BenchmarkLoggerScope-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkEvaluateRouteWithSingleAllowGuard-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkNewHostWithCapabilities-20", + "metric": "B/op", + "baseline": 592, + "current": 592, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./plugin", + "benchmark": "BenchmarkNewHostWithCapabilities-20", + "metric": "allocs/op", + "baseline": 4, + "current": 4, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkBuildTargetJSONBootstrap-20", + "metric": "B/op", + "baseline": 408, + "current": 408, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkBuildTargetJSONBootstrap-20", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePath-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePath-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePathMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./prerender", + "benchmark": "BenchmarkNormalizeRoutePathMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlan-20", + "metric": "B/op", + "baseline": 2720, + "current": 2720, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlan-20", + "metric": "allocs/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "metric": "B/op", + "baseline": 2576, + "current": 2576, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkBuildServiceWorkerAssetPlanMicro-20", + "metric": "allocs/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkMarshalManifestJSON-20", + "metric": "B/op", + "baseline": 496, + "current": 496, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./pwa", + "benchmark": "BenchmarkMarshalManifestJSON-20", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro-20", + "metric": "B/op", + "baseline": 952, + "current": 952, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro-20", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/hooks", + "benchmark": "BenchmarkHarnessStubMethodsMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/hooks", + "benchmark": "BenchmarkHarnessStubMethodsMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/render", + "benchmark": "BenchmarkNewResourceControllerMicro-20", + "metric": "B/op", + "baseline": 240, + "current": 240, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/render", + "benchmark": "BenchmarkNewResourceControllerMicro-20", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/router", + "benchmark": "BenchmarkFixtureStubMethodsMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/router", + "benchmark": "BenchmarkFixtureStubMethodsMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/ssr", + "benchmark": "BenchmarkNormalizeStaticRoutePathMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./testkit/ssr", + "benchmark": "BenchmarkNormalizeStaticRoutePathMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapBinary-20", + "metric": "B/op", + "baseline": 402, + "current": 402, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapBinary-20", + "metric": "allocs/op", + "baseline": 4, + "current": 4, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapJSON-20", + "metric": "B/op", + "baseline": 3483, + "current": 3483, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalSSRBootstrapJSON-20", + "metric": "allocs/op", + "baseline": 43, + "current": 43, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "metric": "B/op", + "baseline": 5542, + "current": 5542, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-20", + "metric": "allocs/op", + "baseline": 81, + "current": 81, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderBootstrapReferenceScript-20", + "metric": "B/op", + "baseline": 1753, + "current": 1753, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderBootstrapReferenceScript-20", + "metric": "allocs/op", + "baseline": 19, + "current": 19, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringMicro-20", + "metric": "B/op", + "baseline": 64, + "current": 64, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringMicro-20", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringPublicSSRSurface-20", + "metric": "B/op", + "baseline": 4176, + "current": 4176, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkRenderToStringPublicSSRSurface-20", + "metric": "allocs/op", + "baseline": 55, + "current": 55, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "metric": "B/op", + "baseline": 1976, + "current": 1976, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapBinary-20", + "metric": "allocs/op", + "baseline": 42, + "current": 42, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "metric": "B/op", + "baseline": 2328, + "current": 2328, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./ui", + "benchmark": "BenchmarkUnmarshalSSRBootstrapJSON-20", + "metric": "allocs/op", + "baseline": 54, + "current": 54, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportState-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportState-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportStateMicro-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkComputeViewportStateMicro-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "native", + "package": "./virtualization", + "benchmark": "BenchmarkViewportDiagnosticsWithRowLifecycle-20", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkBuildMultipartFormData", + "metric": "B/op", + "baseline": 392, + "current": 392, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkBuildMultipartFormData", + "metric": "allocs/op", + "baseline": 35, + "current": 35, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkMergeResolvedMutation", + "metric": "B/op", + "baseline": 696, + "current": 696, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkMergeResolvedMutation", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationID", + "metric": "B/op", + "baseline": 40, + "current": 40, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationID", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationIDMicro", + "metric": "B/op", + "baseline": 63, + "current": 63, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkNormalizeMutationIDMicro", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkResolveMutationQueueOptions", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./fetch", + "benchmark": "BenchmarkResolveMutationQueueOptions", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "metric": "B/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionNoArgsInvoke", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionStringInvoke", + "metric": "B/op", + "baseline": 80, + "current": 80, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkLegacyWrapFunctionStringInvoke", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterAppendChild", + "metric": "B/op", + "baseline": 344, + "current": 344, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterAppendChild", + "metric": "allocs/op", + "baseline": 33, + "current": 33, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterBatchAppend16", + "metric": "B/op", + "baseline": 1777, + "current": 1777, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterBatchAppend16", + "metric": "allocs/op", + "baseline": 171, + "current": 171, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterCreateElement", + "metric": "B/op", + "baseline": 248, + "current": 248, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterCreateElement", + "metric": "allocs/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterGetElementById", + "metric": "B/op", + "baseline": 240, + "current": 240, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterGetElementById", + "metric": "allocs/op", + "baseline": 23, + "current": 23, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelector", + "metric": "B/op", + "baseline": 240, + "current": 240, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelector", + "metric": "allocs/op", + "baseline": 23, + "current": 23, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterQuerySelectorAll", + "metric": "allocs/op", + "baseline": 27, + "current": 27, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetAttribute", + "metric": "B/op", + "baseline": 136, + "current": 136, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetAttribute", + "metric": "allocs/op", + "baseline": 13, + "current": 13, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetPropertyString", + "metric": "B/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterSetPropertyString", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "metric": "B/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionNoArgsInvoke", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "metric": "B/op", + "baseline": 80, + "current": 80, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMDOMAdapterWrapFunctionStringInvoke", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMEventAdapterAddRemoveListener", + "metric": "B/op", + "baseline": 192, + "current": 192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "benchmark": "BenchmarkWASMEventAdapterAddRemoveListener", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAreDepsEqual3Primitives", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryGetAtom", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting", + "metric": "B/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryInitAtomExisting", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers", + "metric": "B/op", + "baseline": 264, + "current": 264, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySetAtom32Subscribers", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "metric": "B/op", + "baseline": 192, + "current": 192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkAtomRegistryUnsubscribeMany8", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8", + "metric": "B/op", + "baseline": 1536, + "current": 1536, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCleanupAtomSubscriptions8", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32", + "metric": "B/op", + "baseline": 21072, + "current": 21072, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitDeletionDomlessSubtree32", + "metric": "allocs/op", + "baseline": 171, + "current": 171, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCommitWorkPlacementChain16", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkCreateElementHostWithTextChildren", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMAdapterInterfaceCreateElement", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDOMNodeInterfaceEquals", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4", + "metric": "B/op", + "baseline": 744, + "current": 744, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithComponents4", + "metric": "allocs/op", + "baseline": 9, + "current": 9, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren", + "metric": "B/op", + "baseline": 664, + "current": 664, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkDivWithTextChildren", + "metric": "allocs/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkElementLiteralCreation", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkEnqueueUI", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualInt", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFastEqualString", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFetchStateCopy", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberAllocation", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberHotFieldScan256", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFiberSiblingWalk256", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "metric": "allocs/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "metric": "allocs/op", + "baseline": 32, + "current": 32, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "metric": "allocs/op", + "baseline": 146, + "current": 146, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "metric": "B/op", + "baseline": 41650, + "current": 41650, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "metric": "allocs/op", + "baseline": 130, + "current": 130, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGetGlobalRuntimeLazy", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKey", + "metric": "B/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKey", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKeyCode", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetKeyCode", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetTarget", + "metric": "B/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetTarget", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetValue", + "metric": "B/op", + "baseline": 24, + "current": 24, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventGetValue", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventIsChecked", + "metric": "B/op", + "baseline": 8, + "current": 8, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoEventIsChecked", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGetter", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomGlobalInit", + "metric": "allocs/op", + "baseline": 9, + "current": 9, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomIntUpdate", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset", + "metric": "B/op", + "baseline": 444, + "current": 444, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomPointerNilReset", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseAtomStableRerender", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseCallbackSameDeps", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseEffectSameDeps", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchInit", + "metric": "B/op", + "baseline": 680, + "current": 680, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchInit", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFetchRefetchUnavailable", + "metric": "allocs/op", + "baseline": 3, + "current": 3, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseFuncWrap", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseIdStable", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps", + "metric": "B/op", + "baseline": 109, + "current": 109, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseMemoSameDeps", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseRefStable", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateGlobalInit", + "metric": "B/op", + "baseline": 1024, + "current": 1024, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateGlobalInit", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate", + "metric": "B/op", + "baseline": 472, + "current": 472, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStateIntDirectUpdate", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset", + "metric": "B/op", + "baseline": 436, + "current": 436, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkGoUseStatePointerNilReset", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksIndexResetHotPath", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHooksPackedStateRead", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate", + "metric": "B/op", + "baseline": 450353, + "current": 450353, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeFirstUpdate", + "metric": "allocs/op", + "baseline": 5757, + "current": 5757, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateMediumTreeReuse", + "metric": "allocs/op", + "baseline": 6019, + "current": 6019, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse", + "metric": "B/op", + "baseline": 8520, + "current": 8520, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateSimpleReuse", + "metric": "allocs/op", + "baseline": 70, + "current": 70, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback", + "metric": "B/op", + "baseline": 9192, + "current": 9192, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkHydrateTagMismatchFallback", + "metric": "allocs/op", + "baseline": 83, + "current": 83, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "metric": "B/op", + "baseline": 1312, + "current": 1312, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "metric": "allocs/op", + "baseline": 6, + "current": 6, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkIsNilableTypeCachedPointer", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "metric": "B/op", + "baseline": 968, + "current": 968, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkProcessUIQueueBatch64", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenDifferentPointer", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkPropsEqualChildrenSamePointer", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16", + "metric": "B/op", + "baseline": 5681, + "current": 5681, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenKeyedStableList16", + "metric": "allocs/op", + "baseline": 18, + "current": 18, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16", + "metric": "B/op", + "baseline": 5632, + "current": 5632, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenStableList16", + "metric": "allocs/op", + "baseline": 16, + "current": 16, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16", + "metric": "B/op", + "baseline": 5656, + "current": 5656, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkReconcileChildrenWithFragments16", + "metric": "allocs/op", + "baseline": 17, + "current": 17, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRender", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderPortalToSelector", + "metric": "allocs/op", + "baseline": 55, + "current": 55, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderSteadyState", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo", + "metric": "B/op", + "baseline": 3112, + "current": 3112, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRenderTo", + "metric": "allocs/op", + "baseline": 20, + "current": 20, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRunEffectsChain16", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkRuntimeLayoutBaselines", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdate", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateForFiberDepth32", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState", + "metric": "B/op", + "baseline": 352, + "current": 352, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkScheduleUpdateSteadyState", + "metric": "allocs/op", + "baseline": 1, + "current": 1, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkSchedulerInterfaceSetTimeout", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTextShim", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkTextShim", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender", + "metric": "B/op", + "baseline": 1120, + "current": 1120, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesInitialRender", + "metric": "allocs/op", + "baseline": 7, + "current": 7, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkUpdateDomPropertiesSteadyState", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4", + "metric": "B/op", + "baseline": 760, + "current": 760, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "benchmark": "BenchmarkWithComponentsGeneric4", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkClientCanExchangeMicro", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct", + "metric": "B/op", + "baseline": 1136, + "current": 1136, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkDecodeMapToStruct", + "metric": "allocs/op", + "baseline": 29, + "current": 29, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString", + "metric": "B/op", + "baseline": 480, + "current": 480, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkInteropErrorString", + "metric": "allocs/op", + "baseline": 5, + "current": 5, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkLocalStorageGetItem", + "metric": "B/op", + "baseline": 96, + "current": 96, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkLocalStorageGetItem", + "metric": "allocs/op", + "baseline": 10, + "current": 10, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkModuleCall", + "metric": "B/op", + "baseline": 128, + "current": 128, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./interop", + "benchmark": "BenchmarkModuleCall", + "metric": "allocs/op", + "baseline": 11, + "current": 11, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkCurrentNestedLayoutRoute", + "metric": "allocs/op", + "baseline": 685, + "current": 685, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkEvaluateNavigationNestedLayouts", + "metric": "B/op", + "baseline": 3552, + "current": 3552, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkEvaluateNavigationNestedLayouts", + "metric": "allocs/op", + "baseline": 41, + "current": 41, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkResolveRouteStackNestedLayout", + "metric": "B/op", + "baseline": 1808, + "current": 1808, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkResolveRouteStackNestedLayout", + "metric": "allocs/op", + "baseline": 15, + "current": 15, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro", + "metric": "B/op", + "baseline": 952, + "current": 952, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./router", + "benchmark": "BenchmarkRouteContractMustHrefForMicro", + "metric": "allocs/op", + "baseline": 12, + "current": 12, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalSnapshotJSONMicro", + "metric": "B/op", + "baseline": 448, + "current": 448, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalSnapshotJSONMicro", + "metric": "allocs/op", + "baseline": 13, + "current": 13, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalUnmarshalSnapshotJSON", + "metric": "B/op", + "baseline": 1528, + "current": 1528, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkMarshalUnmarshalSnapshotJSON", + "metric": "allocs/op", + "baseline": 38, + "current": 38, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkSnapshotSelect", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkSnapshotSelect", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkUnmarshalSnapshotJSONMicro", + "metric": "B/op", + "baseline": 1656, + "current": 1656, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./state", + "benchmark": "BenchmarkUnmarshalSnapshotJSONMicro", + "metric": "allocs/op", + "baseline": 25, + "current": 25, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookCurrentMicroWasm", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookCurrentMicroWasm", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "benchmark": "BenchmarkRenderHookStateRerenderMicroWasm", + "metric": "allocs/op", + "baseline": 35, + "current": 35, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneStringMapMicroWasm", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneStringMapMicroWasm", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneURLValuesMicroWasm", + "metric": "B/op", + "baseline": 48, + "current": 48, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./testkit/router", + "benchmark": "BenchmarkCloneURLValuesMicroWasm", + "metric": "allocs/op", + "baseline": 2, + "current": 2, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "metric": "B/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + }, + { + "lane": "wasm", + "package": "./utils", + "benchmark": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "metric": "allocs/op", + "baseline": 0, + "current": 0, + "delta": 0, + "deltaPct": 0, + "direction": "unchanged" + } + ] + } +} diff --git a/docs/benchmarks/run-arm64.json b/docs/benchmarks/run-arm64.json new file mode 100644 index 00000000..a39b0ae9 --- /dev/null +++ b/docs/benchmarks/run-arm64.json @@ -0,0 +1,10457 @@ +{ + "ok": false, + "root": ".", + "generatedAt": "2026-06-13T13:20:16Z", + "goVersion": "go1.26.3", + "goos": "windows", + "goarch": "arm64", + "selectedLanes": [ + "native", + "wasm" + ], + "bench": ".", + "count": 1, + "packageParallelism": 1, + "reportPath": "./docs/benchmarks/run-arm64.json", + "packageCount": 34, + "benchmarkCount": 500, + "failedPackages": 3, + "packages": [ + { + "lane": "native", + "package": "./devtools", + "workspace": "./devtools", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkSanitizeBugCaptureBundleForSupport-18", + "bucket": "compute", + "samples": [ + { + "iterations": 18108, + "metrics": { + "B/op": 38614, + "allocs/op": 100, + "ns/op": 62288 + }, + "raw": "BenchmarkSanitizeBugCaptureBundleForSupport-18 \t 18108\t 62288 ns/op\t 38614 B/op\t 100 allocs/op" + } + ], + "averageMetrics": { + "B/op": 38614, + "allocs/op": 100, + "ns/op": 62288 + } + }, + { + "name": "BenchmarkExportSupportDiagnosticBundleJSON-18", + "bucket": "memory", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 44081, + "allocs/op": 116, + "ns/op": 105294 + }, + "raw": "BenchmarkExportSupportDiagnosticBundleJSON-18 \t 10000\t 105294 ns/op\t 44081 B/op\t 116 allocs/op" + } + ], + "averageMetrics": { + "B/op": 44081, + "allocs/op": 116, + "ns/op": 105294 + } + }, + { + "name": "BenchmarkSnapshotNowMicro-18", + "bucket": "memory", + "samples": [ + { + "iterations": 3322387, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 307.6 + }, + "raw": "BenchmarkSnapshotNowMicro-18 \t 3322387\t 307.6 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 307.6 + } + }, + { + "name": "BenchmarkCompareSnapshotsMicro-18", + "bucket": "memory", + "samples": [ + { + "iterations": 5670, + "metrics": { + "B/op": 89088, + "allocs/op": 1256, + "ns/op": 191634 + }, + "raw": "BenchmarkCompareSnapshotsMicro-18 \t 5670\t 191634 ns/op\t 89088 B/op\t 1256 allocs/op" + } + ], + "averageMetrics": { + "B/op": 89088, + "allocs/op": 1256, + "ns/op": 191634 + } + } + ] + }, + { + "lane": "native", + "package": "./diagnostics", + "workspace": "./diagnostics", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkNewReport-18", + "bucket": "compute", + "samples": [ + { + "iterations": 128278, + "metrics": { + "B/op": 3947, + "allocs/op": 39, + "ns/op": 9344 + }, + "raw": "BenchmarkNewReport-18 \t 128278\t 9344 ns/op\t 3947 B/op\t 39 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3947, + "allocs/op": 39, + "ns/op": 9344 + } + }, + { + "name": "BenchmarkWriteHTTPError-18", + "bucket": "compute", + "samples": [ + { + "iterations": 102514, + "metrics": { + "B/op": 6443, + "allocs/op": 41, + "ns/op": 12367 + }, + "raw": "BenchmarkWriteHTTPError-18 \t 102514\t 12367 ns/op\t 6443 B/op\t 41 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6443, + "allocs/op": 41, + "ns/op": 12367 + } + }, + { + "name": "BenchmarkNewReportMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 126024, + "metrics": { + "B/op": 3963, + "allocs/op": 41, + "ns/op": 9971 + }, + "raw": "BenchmarkNewReportMicro-18 \t 126024\t 9971 ns/op\t 3963 B/op\t 41 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3963, + "allocs/op": 41, + "ns/op": 9971 + } + } + ] + }, + { + "lane": "native", + "package": "./head", + "workspace": "./head", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkRenderToString-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 17754, + "metrics": { + "B/op": 33514, + "allocs/op": 255, + "ns/op": 58389 + }, + "raw": "BenchmarkRenderToString-18 \t 17754\t 58389 ns/op\t 33514 B/op\t 255 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33514, + "allocs/op": 255, + "ns/op": 58389 + } + }, + { + "name": "BenchmarkRenderJSONLD-18", + "bucket": "memory", + "samples": [ + { + "iterations": 165866, + "metrics": { + "B/op": 9650, + "allocs/op": 45, + "ns/op": 12143 + }, + "raw": "BenchmarkRenderJSONLD-18 \t 165866\t 12143 ns/op\t 9650 B/op\t 45 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9650, + "allocs/op": 45, + "ns/op": 12143 + } + }, + { + "name": "BenchmarkMergeDocumentMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 10576898, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 119.4 + }, + "raw": "BenchmarkMergeDocumentMicro-18 \t10576898\t 119.4 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 119.4 + } + } + ] + }, + { + "lane": "native", + "package": "./hotreload", + "workspace": "./hotreload", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkEnabled-18", + "bucket": "compute", + "samples": [ + { + "iterations": 469304732, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.5 + }, + "raw": "BenchmarkEnabled-18 \t469304732\t 2.500 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.5 + } + }, + { + "name": "BenchmarkEnableDisableCycle-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 484760934, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.631 + }, + "raw": "BenchmarkEnableDisableCycle-18 \t484760934\t 2.631 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.631 + } + }, + { + "name": "BenchmarkEnableDisableCycleMicro-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.3127 + }, + "raw": "BenchmarkEnableDisableCycleMicro-18 \t1000000000\t 0.3127 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.3127 + } + } + ] + }, + { + "lane": "native", + "package": "./html", + "workspace": "./html", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkTagDivWithCommonProps-18", + "bucket": "compute", + "samples": [ + { + "iterations": 977842, + "metrics": { + "B/op": 1032, + "allocs/op": 17, + "ns/op": 1227 + }, + "raw": "BenchmarkTagDivWithCommonProps-18 \t 977842\t 1227 ns/op\t 1032 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1032, + "allocs/op": 17, + "ns/op": 1227 + } + }, + { + "name": "BenchmarkCustomElementWithAttributesAndProperties-18", + "bucket": "compute", + "samples": [ + { + "iterations": 921820, + "metrics": { + "B/op": 1184, + "allocs/op": 15, + "ns/op": 1955 + }, + "raw": "BenchmarkCustomElementWithAttributesAndProperties-18 \t 921820\t 1955 ns/op\t 1184 B/op\t 15 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1184, + "allocs/op": 15, + "ns/op": 1955 + } + }, + { + "name": "BenchmarkDivNodeConstructionMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 1453108, + "metrics": { + "B/op": 664, + "allocs/op": 9, + "ns/op": 895.5 + }, + "raw": "BenchmarkDivNodeConstructionMicro-18 \t 1453108\t 895.5 ns/op\t 664 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 9, + "ns/op": 895.5 + } + }, + { + "name": "BenchmarkMergePropsHotPath-18", + "bucket": "compute", + "samples": [ + { + "iterations": 332842, + "metrics": { + "B/op": 3648, + "allocs/op": 10, + "ns/op": 3871 + }, + "raw": "BenchmarkMergePropsHotPath-18 \t 332842\t 3871 ns/op\t 3648 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3648, + "allocs/op": 10, + "ns/op": 3871 + } + } + ] + }, + { + "lane": "native", + "package": "./html/shorthand", + "workspace": "./html/shorthand", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkTagWithMixedArgs-18", + "bucket": "compute", + "samples": [ + { + "iterations": 639900, + "metrics": { + "B/op": 2960, + "allocs/op": 24, + "ns/op": 1972 + }, + "raw": "BenchmarkTagWithMixedArgs-18 \t 639900\t 1972 ns/op\t 2960 B/op\t 24 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2960, + "allocs/op": 24, + "ns/op": 1972 + } + }, + { + "name": "BenchmarkClassNames-18", + "bucket": "compute", + "samples": [ + { + "iterations": 3546208, + "metrics": { + "B/op": 256, + "allocs/op": 4, + "ns/op": 418.9 + }, + "raw": "BenchmarkClassNames-18 \t 3546208\t 418.9 ns/op\t 256 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 256, + "allocs/op": 4, + "ns/op": 418.9 + } + } + ] + }, + { + "lane": "native", + "package": "./i18n", + "workspace": "./i18n", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkBundleTranslate-18", + "bucket": "compute", + "samples": [ + { + "iterations": 628153, + "metrics": { + "B/op": 992, + "allocs/op": 14, + "ns/op": 1918 + }, + "raw": "BenchmarkBundleTranslate-18 \t 628153\t 1918 ns/op\t 992 B/op\t 14 allocs/op" + } + ], + "averageMetrics": { + "B/op": 992, + "allocs/op": 14, + "ns/op": 1918 + } + }, + { + "name": "BenchmarkNormalizeLocaleMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 2224154, + "metrics": { + "B/op": 244, + "allocs/op": 4, + "ns/op": 556.8 + }, + "raw": "BenchmarkNormalizeLocaleMicro-18 \t 2224154\t 556.8 ns/op\t 244 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 244, + "allocs/op": 4, + "ns/op": 556.8 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/diagnostics", + "workspace": "./internal/diagnostics", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkBuild-18", + "bucket": "compute", + "samples": [ + { + "iterations": 136692, + "metrics": { + "B/op": 3595, + "allocs/op": 34, + "ns/op": 9815 + }, + "raw": "BenchmarkBuild-18 \t 136692\t 9815 ns/op\t 3595 B/op\t 34 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3595, + "allocs/op": 34, + "ns/op": 9815 + } + }, + { + "name": "BenchmarkReportFormatted-18", + "bucket": "compute", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 1801, + "allocs/op": 16, + "ns/op": 1263 + }, + "raw": "BenchmarkReportFormatted-18 \t 1000000\t 1263 ns/op\t 1801 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1801, + "allocs/op": 16, + "ns/op": 1263 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/platform/mockdom", + "workspace": "./internal/platform/mockdom", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1321250, + "metrics": { + "B/op": 1354, + "allocs/op": 7, + "ns/op": 820.4 + }, + "raw": "BenchmarkMockDOMAdapterCreateElementAndAppendChild-18 \t 1321250\t 820.4 ns/op\t 1354 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1354, + "allocs/op": 7, + "ns/op": 820.4 + } + }, + { + "name": "BenchmarkMockSchedulerFlushAll-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 779174, + "metrics": { + "B/op": 816, + "allocs/op": 27, + "ns/op": 1749 + }, + "raw": "BenchmarkMockSchedulerFlushAll-18 \t 779174\t 1749 ns/op\t 816 B/op\t 27 allocs/op" + } + ], + "averageMetrics": { + "B/op": 816, + "allocs/op": 27, + "ns/op": 1749 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/pluginruntime", + "workspace": "./internal/pluginruntime", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkKernelResolveService-18", + "bucket": "compute", + "samples": [ + { + "iterations": 61487694, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.5 + }, + "raw": "BenchmarkKernelResolveService-18 \t61487694\t 19.50 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.5 + } + }, + { + "name": "BenchmarkKernelListDevtoolsSections-18", + "bucket": "compute", + "samples": [ + { + "iterations": 3261909, + "metrics": { + "B/op": 328, + "allocs/op": 6, + "ns/op": 432.4 + }, + "raw": "BenchmarkKernelListDevtoolsSections-18 \t 3261909\t 432.4 ns/op\t 328 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 328, + "allocs/op": 6, + "ns/op": 432.4 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/runtime", + "workspace": "./internal/runtime", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 87, + "benchmarks": [ + { + "name": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 28623, + "metrics": { + "B/op": 10125, + "allocs/op": 150, + "ns/op": 43860 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16-18 \t 28623\t 43860 ns/op\t 10125 B/op\t 150 allocs/op" + } + ], + "averageMetrics": { + "B/op": 10125, + "allocs/op": 150, + "ns/op": 43860 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 391944, + "metrics": { + "B/op": 184, + "allocs/op": 8, + "ns/op": 3154 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16-18 \t 391944\t 3154 ns/op\t 184 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 184, + "allocs/op": 8, + "ns/op": 3154 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 29133, + "metrics": { + "B/op": 10015, + "allocs/op": 134, + "ns/op": 39489 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16-18 \t 29133\t 39489 ns/op\t 10015 B/op\t 134 allocs/op" + } + ], + "averageMetrics": { + "B/op": 10015, + "allocs/op": 134, + "ns/op": 39489 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 343795, + "metrics": { + "B/op": 240, + "allocs/op": 11, + "ns/op": 3565 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16-18 \t 343795\t 3565 ns/op\t 240 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 11, + "ns/op": 3565 + } + }, + { + "name": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 249669, + "metrics": { + "B/op": 759, + "allocs/op": 17, + "ns/op": 4831 + }, + "raw": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16-18 \t 249669\t 4831 ns/op\t 759 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 759, + "allocs/op": 17, + "ns/op": 4831 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 23389, + "metrics": { + "B/op": 3077, + "allocs/op": 33, + "ns/op": 43929 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64-18 \t 23389\t 43929 ns/op\t 3077 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3077, + "allocs/op": 33, + "ns/op": 43929 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 25854, + "metrics": { + "B/op": 3077, + "allocs/op": 33, + "ns/op": 47633 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64-18 \t 25854\t 47633 ns/op\t 3077 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3077, + "allocs/op": 33, + "ns/op": 47633 + } + }, + { + "name": "BenchmarkIsNilableTypeCachedPointer-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 76886604, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.27 + }, + "raw": "BenchmarkIsNilableTypeCachedPointer-18 \t76886604\t 14.27 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14.27 + } + }, + { + "name": "BenchmarkFastEqualInt-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 326966300, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.776 + }, + "raw": "BenchmarkFastEqualInt-18 \t326966300\t 3.776 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.776 + } + }, + { + "name": "BenchmarkFastEqualString-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 257506806, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.873 + }, + "raw": "BenchmarkFastEqualString-18 \t257506806\t 4.873 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.873 + } + }, + { + "name": "BenchmarkAreDepsEqual3Primitives-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 91406980, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 12.75 + }, + "raw": "BenchmarkAreDepsEqual3Primitives-18 \t91406980\t 12.75 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 12.75 + } + }, + { + "name": "BenchmarkGoUseStateIntDirectUpdate-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1884418, + "metrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 664.2 + }, + "raw": "BenchmarkGoUseStateIntDirectUpdate-18 \t 1884418\t 664.2 ns/op\t 599 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 664.2 + } + }, + { + "name": "BenchmarkGoUseStatePointerNilReset-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2063056, + "metrics": { + "B/op": 564, + "allocs/op": 3, + "ns/op": 591.8 + }, + "raw": "BenchmarkGoUseStatePointerNilReset-18 \t 2063056\t 591.8 ns/op\t 564 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 564, + "allocs/op": 3, + "ns/op": 591.8 + } + }, + { + "name": "BenchmarkGoUseMemoSameDeps-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 186926, + "metrics": { + "B/op": 239, + "allocs/op": 3, + "ns/op": 6691 + }, + "raw": "BenchmarkGoUseMemoSameDeps-18 \t 186926\t 6691 ns/op\t 239 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 239, + "allocs/op": 3, + "ns/op": 6691 + } + }, + { + "name": "BenchmarkGoUseCallbackSameDeps-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 219636, + "metrics": { + "B/op": 225, + "allocs/op": 3, + "ns/op": 5549 + }, + "raw": "BenchmarkGoUseCallbackSameDeps-18 \t 219636\t 5549 ns/op\t 225 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 225, + "allocs/op": 3, + "ns/op": 5549 + } + }, + { + "name": "BenchmarkGoUseRefStable-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 222222, + "metrics": { + "B/op": 208, + "allocs/op": 2, + "ns/op": 5303 + }, + "raw": "BenchmarkGoUseRefStable-18 \t 222222\t 5303 ns/op\t 208 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 208, + "allocs/op": 2, + "ns/op": 5303 + } + }, + { + "name": "BenchmarkGoUseIdStable-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 232760, + "metrics": { + "B/op": 225, + "allocs/op": 2, + "ns/op": 5203 + }, + "raw": "BenchmarkGoUseIdStable-18 \t 232760\t 5203 ns/op\t 225 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 225, + "allocs/op": 2, + "ns/op": 5203 + } + }, + { + "name": "BenchmarkGoUseFuncWrap-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 222158, + "metrics": { + "B/op": 208, + "allocs/op": 2, + "ns/op": 5496 + }, + "raw": "BenchmarkGoUseFuncWrap-18 \t 222158\t 5496 ns/op\t 208 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 208, + "allocs/op": 2, + "ns/op": 5496 + } + }, + { + "name": "BenchmarkGoUseEffectSameDeps-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 222494, + "metrics": { + "B/op": 224, + "allocs/op": 3, + "ns/op": 5530 + }, + "raw": "BenchmarkGoUseEffectSameDeps-18 \t 222494\t 5530 ns/op\t 224 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 224, + "allocs/op": 3, + "ns/op": 5530 + } + }, + { + "name": "BenchmarkGoUseFetchStubInit-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2817 + }, + "raw": "BenchmarkGoUseFetchStubInit-18 \t1000000000\t 0.2817 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2817 + } + }, + { + "name": "BenchmarkGoUseFetchStubGetter-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 471792693, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.584 + }, + "raw": "BenchmarkGoUseFetchStubGetter-18 \t471792693\t 2.584 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.584 + } + }, + { + "name": "BenchmarkGoUseFetchStubRefetch-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 570688578, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.999 + }, + "raw": "BenchmarkGoUseFetchStubRefetch-18 \t570688578\t 1.999 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.999 + } + }, + { + "name": "BenchmarkFormatHookIDCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 11326203, + "metrics": { + "B/op": 13, + "allocs/op": 1, + "ns/op": 108 + }, + "raw": "BenchmarkFormatHookIDCurrentVsLegacy/legacy-18 \t11326203\t 108.0 ns/op\t 13 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 13, + "allocs/op": 1, + "ns/op": 108 + } + }, + { + "name": "BenchmarkFormatHookIDCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 36541026, + "metrics": { + "B/op": 10, + "allocs/op": 1, + "ns/op": 32.22 + }, + "raw": "BenchmarkFormatHookIDCurrentVsLegacy/current-18 \t36541026\t 32.22 ns/op\t 10 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 10, + "allocs/op": 1, + "ns/op": 32.22 + } + }, + { + "name": "BenchmarkDivWithTextChildren-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1982284, + "metrics": { + "B/op": 872, + "allocs/op": 7, + "ns/op": 617.4 + }, + "raw": "BenchmarkDivWithTextChildren-18 \t 1982284\t 617.4 ns/op\t 872 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 872, + "allocs/op": 7, + "ns/op": 617.4 + } + }, + { + "name": "BenchmarkDivWithComponents4-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1492042, + "metrics": { + "B/op": 1016, + "allocs/op": 10, + "ns/op": 802.4 + }, + "raw": "BenchmarkDivWithComponents4-18 \t 1492042\t 802.4 ns/op\t 1016 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1016, + "allocs/op": 10, + "ns/op": 802.4 + } + }, + { + "name": "BenchmarkWithComponentsGeneric4-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1280241, + "metrics": { + "B/op": 1032, + "allocs/op": 11, + "ns/op": 966.2 + }, + "raw": "BenchmarkWithComponentsGeneric4-18 \t 1280241\t 966.2 ns/op\t 1032 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1032, + "allocs/op": 11, + "ns/op": 966.2 + } + }, + { + "name": "BenchmarkHydrateSimpleReuse-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 119646, + "metrics": { + "B/op": 9040, + "allocs/op": 75, + "ns/op": 10707 + }, + "raw": "BenchmarkHydrateSimpleReuse-18 \t 119646\t 10707 ns/op\t 9040 B/op\t 75 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9040, + "allocs/op": 75, + "ns/op": 10707 + } + }, + { + "name": "BenchmarkHydrateTagMismatchFallback-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 113668, + "metrics": { + "B/op": 9161, + "allocs/op": 78, + "ns/op": 11607 + }, + "raw": "BenchmarkHydrateTagMismatchFallback-18 \t 113668\t 11607 ns/op\t 9161 B/op\t 78 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9161, + "allocs/op": 78, + "ns/op": 11607 + } + }, + { + "name": "BenchmarkHydrateMediumTreeReuse-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 1407, + "metrics": { + "B/op": 467422, + "allocs/op": 7108, + "ns/op": 726792 + }, + "raw": "BenchmarkHydrateMediumTreeReuse-18 \t 1407\t 726792 ns/op\t 467422 B/op\t 7108 allocs/op" + } + ], + "averageMetrics": { + "B/op": 467422, + "allocs/op": 7108, + "ns/op": 726792 + } + }, + { + "name": "BenchmarkHydrateMediumTreeFirstUpdate-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 1770, + "metrics": { + "B/op": 447812, + "allocs/op": 6376, + "ns/op": 732651 + }, + "raw": "BenchmarkHydrateMediumTreeFirstUpdate-18 \t 1770\t 732651 ns/op\t 447812 B/op\t 6376 allocs/op" + } + ], + "averageMetrics": { + "B/op": 447812, + "allocs/op": 6376, + "ns/op": 732651 + } + }, + { + "name": "BenchmarkDOMNodeInterfaceEquals-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 464442476, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.632 + }, + "raw": "BenchmarkDOMNodeInterfaceEquals-18 \t464442476\t 2.632 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.632 + } + }, + { + "name": "BenchmarkDOMAdapterInterfaceCreateElement-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 46257926, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 25.85 + }, + "raw": "BenchmarkDOMAdapterInterfaceCreateElement-18 \t46257926\t 25.85 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 25.85 + } + }, + { + "name": "BenchmarkSchedulerInterfaceSetTimeout-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 35475774, + "metrics": { + "B/op": 45, + "allocs/op": 0, + "ns/op": 44.04 + }, + "raw": "BenchmarkSchedulerInterfaceSetTimeout-18 \t35475774\t 44.04 ns/op\t 45 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 45, + "allocs/op": 0, + "ns/op": 44.04 + } + }, + { + "name": "BenchmarkRuntimeLayoutBaselines-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 104, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 400, + "hooks-align": 8, + "hooks-bytes": 472, + "ns/op": 0.2808 + }, + "raw": "BenchmarkRuntimeLayoutBaselines-18 \t1000000000\t 0.2808 ns/op\t 104.0 element-bytes\t 40.00 fetchstate-bytes\t 8.000 fiber-align\t 400.0 fiber-bytes\t 8.000 hooks-align\t 472.0 hooks-bytes\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 104, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 400, + "hooks-align": 8, + "hooks-bytes": 472, + "ns/op": 0.2808 + } + }, + { + "name": "BenchmarkFiberHotFieldScan256-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1879480, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 631.8 + }, + "raw": "BenchmarkFiberHotFieldScan256-18 \t 1879480\t 631.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 631.8 + } + }, + { + "name": "BenchmarkFiberSiblingWalk256-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1187 + }, + "raw": "BenchmarkFiberSiblingWalk256-18 \t 1000000\t 1187 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1187 + } + }, + { + "name": "BenchmarkHooksIndexResetHotPath-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 149399246, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.6 + }, + "raw": "BenchmarkHooksIndexResetHotPath-18 \t149399246\t 8.600 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.6 + } + }, + { + "name": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 100000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.21 + }, + "raw": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/current-18 \t100000000\t 11.21 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.21 + } + }, + { + "name": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 288943, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4169 + }, + "raw": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/legacy-18 \t 288943\t 4169 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4169 + } + }, + { + "name": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 7388, + "metrics": { + "B/op": 6720, + "allocs/op": 7, + "ns/op": 162756 + }, + "raw": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/current-18 \t 7388\t 162756 ns/op\t 6720 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6720, + "allocs/op": 7, + "ns/op": 162756 + } + }, + { + "name": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 148, + "metrics": { + "B/op": 1266930, + "allocs/op": 1657, + "ns/op": 8162165 + }, + "raw": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/legacy-18 \t 148\t 8162165 ns/op\t 1266930 B/op\t 1657 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1266930, + "allocs/op": 1657, + "ns/op": 8162165 + } + }, + { + "name": "BenchmarkRenderPortalToSelector-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 223426, + "metrics": { + "B/op": 7632, + "allocs/op": 53, + "ns/op": 6381 + }, + "raw": "BenchmarkRenderPortalToSelector-18 \t 223426\t 6381 ns/op\t 7632 B/op\t 53 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7632, + "allocs/op": 53, + "ns/op": 6381 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/large-list-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3576, + "metrics": { + "B/op": 348113, + "allocs/op": 1363, + "ns/op": 325761 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/large-list-18 \t 3576\t 325761 ns/op\t 348113 B/op\t 1363 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348113, + "allocs/op": 1363, + "ns/op": 325761 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/nested-routes-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6524, + "metrics": { + "B/op": 348141, + "allocs/op": 1363, + "ns/op": 276621 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/nested-routes-18 \t 6524\t 276621 ns/op\t 348141 B/op\t 1363 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348141, + "allocs/op": 1363, + "ns/op": 276621 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/async-dashboard-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4202, + "metrics": { + "B/op": 348140, + "allocs/op": 1363, + "ns/op": 320807 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/async-dashboard-18 \t 4202\t 320807 ns/op\t 348140 B/op\t 1363 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348140, + "allocs/op": 1363, + "ns/op": 320807 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/portal-overlays-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3817, + "metrics": { + "B/op": 348142, + "allocs/op": 1363, + "ns/op": 327231 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/portal-overlays-18 \t 3817\t 327231 ns/op\t 348142 B/op\t 1363 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348142, + "allocs/op": 1363, + "ns/op": 327231 + } + }, + { + "name": "BenchmarkCreateElementHostWithTextChildren-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1391428, + "metrics": { + "B/op": 936, + "allocs/op": 7, + "ns/op": 1014 + }, + "raw": "BenchmarkCreateElementHostWithTextChildren-18 \t 1391428\t 1014 ns/op\t 936 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 936, + "allocs/op": 7, + "ns/op": 1014 + } + }, + { + "name": "BenchmarkCreateElementHostWithDirectTextChild-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1867906, + "metrics": { + "B/op": 584, + "allocs/op": 6, + "ns/op": 642.3 + }, + "raw": "BenchmarkCreateElementHostWithDirectTextChild-18 \t 1867906\t 642.3 ns/op\t 584 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 584, + "allocs/op": 6, + "ns/op": 642.3 + } + }, + { + "name": "BenchmarkPropsEqualChildrenSamePointer-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 14658152, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 80.88 + }, + "raw": "BenchmarkPropsEqualChildrenSamePointer-18 \t14658152\t 80.88 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 80.88 + } + }, + { + "name": "BenchmarkPropsEqualChildrenDifferentPointer-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 17340212, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 68.66 + }, + "raw": "BenchmarkPropsEqualChildrenDifferentPointer-18 \t17340212\t 68.66 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 68.66 + } + }, + { + "name": "BenchmarkReconcileChildrenStableList16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 365884, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3316 + }, + "raw": "BenchmarkReconcileChildrenStableList16-18 \t 365884\t 3316 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3316 + } + }, + { + "name": "BenchmarkReconcileChildrenWithFragments16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 354619, + "metrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 3505 + }, + "raw": "BenchmarkReconcileChildrenWithFragments16-18 \t 354619\t 3505 ns/op\t 24 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 3505 + } + }, + { + "name": "BenchmarkReconcileChildrenKeyedStableList16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 310335, + "metrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 4033 + }, + "raw": "BenchmarkReconcileChildrenKeyedStableList16-18 \t 310335\t 4033 ns/op\t 48 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 4033 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 154893, + "metrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 7683 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf-18 \t 154893\t 7683 ns/op\t 776 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 7683 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 155287, + "metrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 7969 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf-18 \t 155287\t 7969 ns/op\t 776 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 7969 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesInitialRender-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1307889, + "metrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 943 + }, + "raw": "BenchmarkUpdateDomPropertiesInitialRender-18 \t 1307889\t 943.0 ns/op\t 1120 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 943 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesSteadyState-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1697332, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 707.2 + }, + "raw": "BenchmarkUpdateDomPropertiesSteadyState-18 \t 1697332\t 707.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 707.2 + } + }, + { + "name": "BenchmarkCommitDeletionDomlessSubtree32-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 63404, + "metrics": { + "B/op": 23184, + "allocs/op": 171, + "ns/op": 17673 + }, + "raw": "BenchmarkCommitDeletionDomlessSubtree32-18 \t 63404\t 17673 ns/op\t 23184 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 23184, + "allocs/op": 171, + "ns/op": 17673 + } + }, + { + "name": "BenchmarkCommitWorkPlacementChain16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1258471, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 976.7 + }, + "raw": "BenchmarkCommitWorkPlacementChain16-18 \t 1258471\t 976.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 976.7 + } + }, + { + "name": "BenchmarkRunEffectsChain16-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3135963, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 388.1 + }, + "raw": "BenchmarkRunEffectsChain16-18 \t 3135963\t 388.1 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 388.1 + } + }, + { + "name": "BenchmarkGetGlobalRuntimeLazy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1384899, + "metrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 910.9 + }, + "raw": "BenchmarkGetGlobalRuntimeLazy-18 \t 1384899\t 910.9 ns/op\t 1536 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 910.9 + } + }, + { + "name": "BenchmarkInitGlobalRuntimeAfterLazyGet-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1258542, + "metrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 913.9 + }, + "raw": "BenchmarkInitGlobalRuntimeAfterLazyGet-18 \t 1258542\t 913.9 ns/op\t 1536 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 913.9 + } + }, + { + "name": "BenchmarkRenderTo-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 642456, + "metrics": { + "B/op": 3400, + "allocs/op": 20, + "ns/op": 2222 + }, + "raw": "BenchmarkRenderTo-18 \t 642456\t 2222 ns/op\t 3400 B/op\t 20 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3400, + "allocs/op": 20, + "ns/op": 2222 + } + }, + { + "name": "BenchmarkScheduleUpdate-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 8311071, + "metrics": { + "B/op": 416, + "allocs/op": 1, + "ns/op": 182 + }, + "raw": "BenchmarkScheduleUpdate-18 \t 8311071\t 182.0 ns/op\t 416 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 416, + "allocs/op": 1, + "ns/op": 182 + } + }, + { + "name": "BenchmarkScheduleUpdateSteadyState-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 33880502, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 35.61 + }, + "raw": "BenchmarkScheduleUpdateSteadyState-18 \t33880502\t 35.61 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 35.61 + } + }, + { + "name": "BenchmarkScheduleUpdateForFiberDepth32-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 2380872, + "metrics": { + "B/op": 864, + "allocs/op": 4, + "ns/op": 545.6 + }, + "raw": "BenchmarkScheduleUpdateForFiberDepth32-18 \t 2380872\t 545.6 ns/op\t 864 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 864, + "allocs/op": 4, + "ns/op": 545.6 + } + }, + { + "name": "BenchmarkRender-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 639259, + "metrics": { + "B/op": 1488, + "allocs/op": 10, + "ns/op": 2059 + }, + "raw": "BenchmarkRender-18 \t 639259\t 2059 ns/op\t 1488 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1488, + "allocs/op": 10, + "ns/op": 2059 + } + }, + { + "name": "BenchmarkRenderSteadyState-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 579830, + "metrics": { + "B/op": 1488, + "allocs/op": 10, + "ns/op": 2134 + }, + "raw": "BenchmarkRenderSteadyState-18 \t 579830\t 2134 ns/op\t 1488 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1488, + "allocs/op": 10, + "ns/op": 2134 + } + }, + { + "name": "BenchmarkEnqueueUI-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 30545931, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 39.61 + }, + "raw": "BenchmarkEnqueueUI-18 \t30545931\t 39.61 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 39.61 + } + }, + { + "name": "BenchmarkProcessUIQueueBatch64-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 542910, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2248 + }, + "raw": "BenchmarkProcessUIQueueBatch64-18 \t 542910\t 2248 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2248 + } + }, + { + "name": "BenchmarkTransitionListRefresh250-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 4956, + "metrics": { + "B/op": 145129, + "allocs/op": 1788, + "ns/op": 231784 + }, + "raw": "BenchmarkTransitionListRefresh250-18 \t 4956\t 231784 ns/op\t 145129 B/op\t 1788 allocs/op" + } + ], + "averageMetrics": { + "B/op": 145129, + "allocs/op": 1788, + "ns/op": 231784 + } + }, + { + "name": "BenchmarkSSRRenderToString100Rows-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 4791, + "metrics": { + "B/op": 219533, + "allocs/op": 2406, + "ns/op": 304698 + }, + "raw": "BenchmarkSSRRenderToString100Rows-18 \t 4791\t 304698 ns/op\t 219533 B/op\t 2406 allocs/op" + } + ], + "averageMetrics": { + "B/op": 219533, + "allocs/op": 2406, + "ns/op": 304698 + } + }, + { + "name": "BenchmarkAtomRegistryInitAtomExisting-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 40567128, + "metrics": { + "B/op": 8, + "allocs/op": 0, + "ns/op": 30.4 + }, + "raw": "BenchmarkAtomRegistryInitAtomExisting-18 \t40567128\t 30.40 ns/op\t 8 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 0, + "ns/op": 30.4 + } + }, + { + "name": "BenchmarkAtomRegistryGetAtom-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 81240267, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15.17 + }, + "raw": "BenchmarkAtomRegistryGetAtom-18 \t81240267\t 15.17 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15.17 + } + }, + { + "name": "BenchmarkAtomRegistrySubscribeUnsubscribe-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 5944000, + "metrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 223.9 + }, + "raw": "BenchmarkAtomRegistrySubscribeUnsubscribe-18 \t 5944000\t 223.9 ns/op\t 192 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 223.9 + } + }, + { + "name": "BenchmarkAtomRegistrySetAtom32Subscribers-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 2388337, + "metrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 576 + }, + "raw": "BenchmarkAtomRegistrySetAtom32Subscribers-18 \t 2388337\t 576.0 ns/op\t 264 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 576 + } + }, + { + "name": "BenchmarkGoUseAtomIntUpdate-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2587069, + "metrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 492.7 + }, + "raw": "BenchmarkGoUseAtomIntUpdate-18 \t 2587069\t 492.7 ns/op\t 599 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 492.7 + } + }, + { + "name": "BenchmarkGoUseAtomPointerNilReset-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2536357, + "metrics": { + "B/op": 572, + "allocs/op": 4, + "ns/op": 452.7 + }, + "raw": "BenchmarkGoUseAtomPointerNilReset-18 \t 2536357\t 452.7 ns/op\t 572 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 572, + "allocs/op": 4, + "ns/op": 452.7 + } + }, + { + "name": "BenchmarkGoUseAtomGetter-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 73702830, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.52 + }, + "raw": "BenchmarkGoUseAtomGetter-18 \t73702830\t 16.52 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.52 + } + }, + { + "name": "BenchmarkGoUseAtomStableRerender-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 216802, + "metrics": { + "B/op": 210, + "allocs/op": 2, + "ns/op": 5597 + }, + "raw": "BenchmarkGoUseAtomStableRerender-18 \t 216802\t 5597 ns/op\t 210 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 210, + "allocs/op": 2, + "ns/op": 5597 + } + }, + { + "name": "BenchmarkCleanupAtomSubscriptions8-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 710744, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1924 + }, + "raw": "BenchmarkCleanupAtomSubscriptions8-18 \t 710744\t 1924 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1924 + } + }, + { + "name": "BenchmarkAtomRegistryUnsubscribeMany8-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 700107, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1819 + }, + "raw": "BenchmarkAtomRegistryUnsubscribeMany8-18 \t 700107\t 1819 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 1819 + } + }, + { + "name": "BenchmarkFiberAllocation-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 55603951, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 22.27 + }, + "raw": "BenchmarkFiberAllocation-18 \t55603951\t 22.27 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 22.27 + } + }, + { + "name": "BenchmarkElementLiteralCreation-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2817 + }, + "raw": "BenchmarkElementLiteralCreation-18 \t1000000000\t 0.2817 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2817 + } + }, + { + "name": "BenchmarkHooksPackedStateRead-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2798 + }, + "raw": "BenchmarkHooksPackedStateRead-18 \t1000000000\t 0.2798 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2798 + } + }, + { + "name": "BenchmarkFetchStateCopy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.281 + }, + "raw": "BenchmarkFetchStateCopy-18 \t1000000000\t 0.2810 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.281 + } + } + ] + }, + { + "lane": "native", + "package": "./internal/runtime2", + "workspace": "./internal/runtime2", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 243, + "benchmarks": [ + { + "name": "BenchmarkBuildCanonicalRenderIR-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 513992, + "metrics": { + "B/op": 1472, + "allocs/op": 18, + "ns/op": 2214 + }, + "raw": "BenchmarkBuildCanonicalRenderIR-18 \t 513992\t 2214 ns/op\t 1472 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1472, + "allocs/op": 18, + "ns/op": 2214 + } + }, + { + "name": "BenchmarkBuildCanonicalPatchStream-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 206582, + "metrics": { + "B/op": 7749, + "allocs/op": 43, + "ns/op": 6900 + }, + "raw": "BenchmarkBuildCanonicalPatchStream-18 \t 206582\t 6900 ns/op\t 7749 B/op\t 43 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7749, + "allocs/op": 43, + "ns/op": 6900 + } + }, + { + "name": "BenchmarkParsePatchStreamTransaction-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4002818, + "metrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 300.5 + }, + "raw": "BenchmarkParsePatchStreamTransaction-18 \t 4002818\t 300.5 ns/op\t 496 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 300.5 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransaction-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 310580, + "metrics": { + "B/op": 5312, + "allocs/op": 38, + "ns/op": 4472 + }, + "raw": "BenchmarkCommitRegionPatchTransaction-18 \t 310580\t 4472 ns/op\t 5312 B/op\t 38 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5312, + "allocs/op": 38, + "ns/op": 4472 + } + }, + { + "name": "BenchmarkCompareLocalVsWorkerBackedRendering/local-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 567562, + "metrics": { + "B/op": 1472, + "allocs/op": 18, + "ns/op": 2962 + }, + "raw": "BenchmarkCompareLocalVsWorkerBackedRendering/local-18 \t 567562\t 2962 ns/op\t 1472 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1472, + "allocs/op": 18, + "ns/op": 2962 + } + }, + { + "name": "BenchmarkCompareLocalVsWorkerBackedRendering/worker-backed-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 129949, + "metrics": { + "B/op": 7749, + "allocs/op": 43, + "ns/op": 10978 + }, + "raw": "BenchmarkCompareLocalVsWorkerBackedRendering/worker-backed-18 \t 129949\t 10978 ns/op\t 7749 B/op\t 43 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7749, + "allocs/op": 43, + "ns/op": 10978 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateDispatchLoop-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3790640, + "metrics": { + "B/op": 8, + "allocs/op": 0, + "dispatch-loop-p50-ns": 244, + "dispatch-loop-p95-ns": 496, + "dispatch-loop-p99-ns": 613, + "dispatch-loop-samples": 926, + "ns/op": 320.3 + }, + "raw": "BenchmarkHandleHostRegionUpdateDispatchLoop-18 \t 3790640\t 320.3 ns/op\t 244.0 dispatch-loop-p50-ns\t 496.0 dispatch-loop-p95-ns\t 613.0 dispatch-loop-p99-ns\t 926.0 dispatch-loop-samples\t 8 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 0, + "dispatch-loop-p50-ns": 244, + "dispatch-loop-p95-ns": 496, + "dispatch-loop-p99-ns": 613, + "dispatch-loop-samples": 926, + "ns/op": 320.3 + } + }, + { + "name": "BenchmarkBuildSnapshotTransportPayloadWithFallback/binary-success-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2125443, + "metrics": { + "B/op": 208, + "allocs/op": 1, + "ns/op": 542.5 + }, + "raw": "BenchmarkBuildSnapshotTransportPayloadWithFallback/binary-success-18 \t 2125443\t 542.5 ns/op\t 208 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 208, + "allocs/op": 1, + "ns/op": 542.5 + } + }, + { + "name": "BenchmarkBuildSnapshotTransportPayloadWithFallback/binary-fallback-structured-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1134, + "metrics": { + "B/op": 369012, + "allocs/op": 8, + "ns/op": 950023 + }, + "raw": "BenchmarkBuildSnapshotTransportPayloadWithFallback/binary-fallback-structured-18 \t 1134\t 950023 ns/op\t 369012 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 369012, + "allocs/op": 8, + "ns/op": 950023 + } + }, + { + "name": "BenchmarkParseSnapshotTransportPayloadWithFallback/binary-tier-binary-payload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 760, + "allocs/op": 13, + "ns/op": 1039 + }, + "raw": "BenchmarkParseSnapshotTransportPayloadWithFallback/binary-tier-binary-payload-18 \t 1000000\t 1039 ns/op\t 760 B/op\t 13 allocs/op" + } + ], + "averageMetrics": { + "B/op": 760, + "allocs/op": 13, + "ns/op": 1039 + } + }, + { + "name": "BenchmarkParseSnapshotTransportPayloadWithFallback/binary-tier-structured-payload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 546178, + "metrics": { + "B/op": 1088, + "allocs/op": 22, + "ns/op": 2525 + }, + "raw": "BenchmarkParseSnapshotTransportPayloadWithFallback/binary-tier-structured-payload-18 \t 546178\t 2525 ns/op\t 1088 B/op\t 22 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1088, + "allocs/op": 22, + "ns/op": 2525 + } + }, + { + "name": "BenchmarkCommitRegionRemoveNodeFilterHeavy/siblings-120-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 108039, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11095 + }, + "raw": "BenchmarkCommitRegionRemoveNodeFilterHeavy/siblings-120-18 \t 108039\t 11095 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11095 + } + }, + { + "name": "BenchmarkCommitRegionRemoveNodeFilterHeavy/siblings-240-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 48829, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 24736 + }, + "raw": "BenchmarkCommitRegionRemoveNodeFilterHeavy/siblings-240-18 \t 48829\t 24736 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 24736 + } + }, + { + "name": "BenchmarkCommitRegionRemoveNodeFilterHeavy/siblings-480-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 19470, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 62013 + }, + "raw": "BenchmarkCommitRegionRemoveNodeFilterHeavy/siblings-480-18 \t 19470\t 62013 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 62013 + } + }, + { + "name": "BenchmarkParsePatchRemoveAttrOpCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 8113848, + "metrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 144.4 + }, + "raw": "BenchmarkParsePatchRemoveAttrOpCurrentVsLegacy/legacy-18 \t 8113848\t 144.4 ns/op\t 24 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 144.4 + } + }, + { + "name": "BenchmarkParsePatchRemoveAttrOpCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 24309360, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 50.24 + }, + "raw": "BenchmarkParsePatchRemoveAttrOpCurrentVsLegacy/current-18 \t24309360\t 50.24 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 50.24 + } + }, + { + "name": "BenchmarkBuildBinaryPatchPayload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 3934251, + "metrics": { + "B/op": 208, + "allocs/op": 1, + "ns/op": 352.2 + }, + "raw": "BenchmarkBuildBinaryPatchPayload-18 \t 3934251\t 352.2 ns/op\t 208 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 208, + "allocs/op": 1, + "ns/op": 352.2 + } + }, + { + "name": "BenchmarkParseBinaryPatchPayload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 6560190, + "metrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 190.3 + }, + "raw": "BenchmarkParseBinaryPatchPayload-18 \t 6560190\t 190.3 ns/op\t 24 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 190.3 + } + }, + { + "name": "BenchmarkBuildStructuredClonePatchEnvelopeJSON-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2372094, + "metrics": { + "B/op": 320, + "allocs/op": 1, + "ns/op": 475.6 + }, + "raw": "BenchmarkBuildStructuredClonePatchEnvelopeJSON-18 \t 2372094\t 475.6 ns/op\t 320 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 320, + "allocs/op": 1, + "ns/op": 475.6 + } + }, + { + "name": "BenchmarkParseStructuredClonePatchEnvelopeJSON-18", + "bucket": "memory", + "samples": [ + { + "iterations": 540483, + "metrics": { + "B/op": 432, + "allocs/op": 7, + "ns/op": 2262 + }, + "raw": "BenchmarkParseStructuredClonePatchEnvelopeJSON-18 \t 540483\t 2262 ns/op\t 432 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 432, + "allocs/op": 7, + "ns/op": 2262 + } + }, + { + "name": "BenchmarkHandleSharedPatchPublishPayload-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 80537452, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15.61 + }, + "raw": "BenchmarkHandleSharedPatchPublishPayload-18 \t80537452\t 15.61 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15.61 + } + }, + { + "name": "BenchmarkGetSharedPatchReadPayload-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 8928099, + "metrics": { + "B/op": 288, + "allocs/op": 1, + "ns/op": 264.5 + }, + "raw": "BenchmarkGetSharedPatchReadPayload-18 \t 8928099\t 264.5 ns/op\t 288 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 288, + "allocs/op": 1, + "ns/op": 264.5 + } + }, + { + "name": "BenchmarkBuildSharedPatchTransportResult/shared-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2921106, + "metrics": { + "B/op": 320, + "allocs/op": 1, + "ns/op": 476 + }, + "raw": "BenchmarkBuildSharedPatchTransportResult/shared-18 \t 2921106\t 476.0 ns/op\t 320 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 320, + "allocs/op": 1, + "ns/op": 476 + } + }, + { + "name": "BenchmarkBuildSharedPatchTransportResult/fallback-unavailable-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3141236, + "metrics": { + "B/op": 320, + "allocs/op": 1, + "ns/op": 406.6 + }, + "raw": "BenchmarkBuildSharedPatchTransportResult/fallback-unavailable-18 \t 3141236\t 406.6 ns/op\t 320 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 320, + "allocs/op": 1, + "ns/op": 406.6 + } + }, + { + "name": "BenchmarkParseSharedPatchPayloadFromPage-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 526702, + "metrics": { + "B/op": 432, + "allocs/op": 7, + "ns/op": 2332 + }, + "raw": "BenchmarkParseSharedPatchPayloadFromPage-18 \t 526702\t 2332 ns/op\t 432 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 432, + "allocs/op": 7, + "ns/op": 2332 + } + }, + { + "name": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/build/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 529, + "allocs/op": 2, + "ns/op": 1133 + }, + "raw": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/build/legacy-18 \t 1000000\t 1133 ns/op\t 529 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 529, + "allocs/op": 2, + "ns/op": 1133 + } + }, + { + "name": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/build/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 1481 + }, + "raw": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/build/current-18 \t 1000000\t 1481 ns/op\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "allocs/op": 1, + "ns/op": 1481 + } + }, + { + "name": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/parse/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 679370, + "metrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 2164 + }, + "raw": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/parse/legacy-18 \t 679370\t 2164 ns/op\t 1945 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 2164 + } + }, + { + "name": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/parse/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 758130, + "metrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 1782 + }, + "raw": "BenchmarkBuildAndParseBinarySnapshotEnvelopeCurrentVsLegacy/parse/current-18 \t 758130\t 1782 ns/op\t 1945 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 1782 + } + }, + { + "name": "BenchmarkParseBinarySnapshotBodyCurrentVsLegacy/legacy_helper_parse-18", + "bucket": "memory", + "samples": [ + { + "iterations": 918392, + "metrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 1820 + }, + "raw": "BenchmarkParseBinarySnapshotBodyCurrentVsLegacy/legacy_helper_parse-18 \t 918392\t 1820 ns/op\t 1945 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 1820 + } + }, + { + "name": "BenchmarkParseBinarySnapshotBodyCurrentVsLegacy/current_direct_parse-18", + "bucket": "memory", + "samples": [ + { + "iterations": 775689, + "metrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 1818 + }, + "raw": "BenchmarkParseBinarySnapshotBodyCurrentVsLegacy/current_direct_parse-18 \t 775689\t 1818 ns/op\t 1945 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1945, + "allocs/op": 35, + "ns/op": 1818 + } + }, + { + "name": "BenchmarkBinarySourceIDTableCurrentVsLegacy/append/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 5994403, + "metrics": { + "B/op": 240, + "allocs/op": 4, + "ns/op": 240.4 + }, + "raw": "BenchmarkBinarySourceIDTableCurrentVsLegacy/append/legacy-18 \t 5994403\t 240.4 ns/op\t 240 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 4, + "ns/op": 240.4 + } + }, + { + "name": "BenchmarkBinarySourceIDTableCurrentVsLegacy/append/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 13283680, + "metrics": { + "B/op": 128, + "allocs/op": 2, + "ns/op": 121.6 + }, + "raw": "BenchmarkBinarySourceIDTableCurrentVsLegacy/append/current-18 \t13283680\t 121.6 ns/op\t 128 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 128, + "allocs/op": 2, + "ns/op": 121.6 + } + }, + { + "name": "BenchmarkBinarySourceIDTableCurrentVsLegacy/parse/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 3093399, + "metrics": { + "B/op": 240, + "allocs/op": 9, + "ns/op": 410.8 + }, + "raw": "BenchmarkBinarySourceIDTableCurrentVsLegacy/parse/legacy-18 \t 3093399\t 410.8 ns/op\t 240 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 9, + "ns/op": 410.8 + } + }, + { + "name": "BenchmarkBinarySourceIDTableCurrentVsLegacy/parse/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2909012, + "metrics": { + "B/op": 240, + "allocs/op": 9, + "ns/op": 385 + }, + "raw": "BenchmarkBinarySourceIDTableCurrentVsLegacy/parse/current-18 \t 2909012\t 385.0 ns/op\t 240 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 9, + "ns/op": 385 + } + }, + { + "name": "BenchmarkBuildBinarySourceValueAnyMapFastPathCurrentVsLegacy/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2004537, + "metrics": { + "B/op": 464, + "allocs/op": 3, + "ns/op": 575.3 + }, + "raw": "BenchmarkBuildBinarySourceValueAnyMapFastPathCurrentVsLegacy/legacy-18 \t 2004537\t 575.3 ns/op\t 464 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 464, + "allocs/op": 3, + "ns/op": 575.3 + } + }, + { + "name": "BenchmarkBuildBinarySourceValueAnyMapFastPathCurrentVsLegacy/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2252703, + "metrics": { + "B/op": 368, + "allocs/op": 3, + "ns/op": 523.5 + }, + "raw": "BenchmarkBuildBinarySourceValueAnyMapFastPathCurrentVsLegacy/current-18 \t 2252703\t 523.5 ns/op\t 368 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 368, + "allocs/op": 3, + "ns/op": 523.5 + } + }, + { + "name": "BenchmarkParseBinarySourceValueNestedCurrentVsLegacy/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 510058, + "metrics": { + "B/op": 2880, + "allocs/op": 58, + "ns/op": 2713 + }, + "raw": "BenchmarkParseBinarySourceValueNestedCurrentVsLegacy/legacy-18 \t 510058\t 2713 ns/op\t 2880 B/op\t 58 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2880, + "allocs/op": 58, + "ns/op": 2713 + } + }, + { + "name": "BenchmarkParseBinarySourceValueNestedCurrentVsLegacy/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 634466, + "metrics": { + "B/op": 2880, + "allocs/op": 58, + "ns/op": 3136 + }, + "raw": "BenchmarkParseBinarySourceValueNestedCurrentVsLegacy/current-18 \t 634466\t 3136 ns/op\t 2880 B/op\t 58 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2880, + "allocs/op": 58, + "ns/op": 3136 + } + }, + { + "name": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/append/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 512, + "allocs/op": 1, + "ns/op": 1100 + }, + "raw": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/append/legacy-18 \t 1000000\t 1100 ns/op\t 512 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 512, + "allocs/op": 1, + "ns/op": 1100 + } + }, + { + "name": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/append/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 512, + "allocs/op": 1, + "ns/op": 1137 + }, + "raw": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/append/current-18 \t 1000000\t 1137 ns/op\t 512 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 512, + "allocs/op": 1, + "ns/op": 1137 + } + }, + { + "name": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/parse/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 397077, + "metrics": { + "B/op": 2864, + "allocs/op": 54, + "ns/op": 3089 + }, + "raw": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/parse/legacy-18 \t 397077\t 3089 ns/op\t 2864 B/op\t 54 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2864, + "allocs/op": 54, + "ns/op": 3089 + } + }, + { + "name": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/parse/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 579118, + "metrics": { + "B/op": 2864, + "allocs/op": 54, + "ns/op": 2603 + }, + "raw": "BenchmarkBinarySourceValuesSectionCurrentVsLegacy/parse/current-18 \t 579118\t 2603 ns/op\t 2864 B/op\t 54 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2864, + "allocs/op": 54, + "ns/op": 2603 + } + }, + { + "name": "BenchmarkCoordinatorGetEntryCurrentVsLegacy/legacy_defer_read_lock-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 37976726, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 37.46 + }, + "raw": "BenchmarkCoordinatorGetEntryCurrentVsLegacy/legacy_defer_read_lock-18 \t37976726\t 37.46 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 37.46 + } + }, + { + "name": "BenchmarkCoordinatorGetEntryCurrentVsLegacy/current_inline_read_unlock-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 70748458, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.36 + }, + "raw": "BenchmarkCoordinatorGetEntryCurrentVsLegacy/current_inline_read_unlock-18 \t70748458\t 18.36 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.36 + } + }, + { + "name": "BenchmarkCoordinatorUpdateRegionCurrentVsLegacy/legacy_forward_to_update_and_get_entry-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 18948066, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 63.33 + }, + "raw": "BenchmarkCoordinatorUpdateRegionCurrentVsLegacy/legacy_forward_to_update_and_get_entry-18 \t18948066\t 63.33 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 63.33 + } + }, + { + "name": "BenchmarkCoordinatorUpdateRegionCurrentVsLegacy/current_direct_update-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 45010746, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 27.31 + }, + "raw": "BenchmarkCoordinatorUpdateRegionCurrentVsLegacy/current_direct_update-18 \t45010746\t 27.31 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 27.31 + } + }, + { + "name": "BenchmarkCoordinatorGetMutableEntryValidatedVsTrusted/validated_get_mutable_entry-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 35798774, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 32.99 + }, + "raw": "BenchmarkCoordinatorGetMutableEntryValidatedVsTrusted/validated_get_mutable_entry-18 \t35798774\t 32.99 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 32.99 + } + }, + { + "name": "BenchmarkCoordinatorGetMutableEntryValidatedVsTrusted/trusted_get_mutable_entry-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 62317591, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.88 + }, + "raw": "BenchmarkCoordinatorGetMutableEntryValidatedVsTrusted/trusted_get_mutable_entry-18 \t62317591\t 19.88 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 19.88 + } + }, + { + "name": "BenchmarkCoordinatorCommitRegionValidatedVsTrusted/validated_commit_region-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 20170846, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 59.26 + }, + "raw": "BenchmarkCoordinatorCommitRegionValidatedVsTrusted/validated_commit_region-18 \t20170846\t 59.26 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 59.26 + } + }, + { + "name": "BenchmarkCoordinatorCommitRegionValidatedVsTrusted/trusted_commit_region-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 22556857, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 54.41 + }, + "raw": "BenchmarkCoordinatorCommitRegionValidatedVsTrusted/trusted_commit_region-18 \t22556857\t 54.41 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 54.41 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-32/legacy_generic-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 121255, + "allocs/op": 1697, + "ns/op": 136059 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-32/legacy_generic-18 \t 10000\t 136059 ns/op\t 121255 B/op\t 1697 allocs/op" + } + ], + "averageMetrics": { + "B/op": 121255, + "allocs/op": 1697, + "ns/op": 136059 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-32/current_fast_path-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 112992, + "allocs/op": 1567, + "ns/op": 126193 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-32/current_fast_path-18 \t 10000\t 126193 ns/op\t 112992 B/op\t 1567 allocs/op" + } + ], + "averageMetrics": { + "B/op": 112992, + "allocs/op": 1567, + "ns/op": 126193 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-128/legacy_generic-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 7558, + "metrics": { + "B/op": 170264, + "allocs/op": 2373, + "ns/op": 201376 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-128/legacy_generic-18 \t 7558\t 201376 ns/op\t 170264 B/op\t 2373 allocs/op" + } + ], + "averageMetrics": { + "B/op": 170264, + "allocs/op": 2373, + "ns/op": 201376 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-128/current_fast_path-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 149985, + "allocs/op": 1857, + "ns/op": 158566 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-128/current_fast_path-18 \t 10000\t 158566 ns/op\t 149985 B/op\t 1857 allocs/op" + } + ], + "averageMetrics": { + "B/op": 149985, + "allocs/op": 1857, + "ns/op": 158566 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-256/legacy_generic-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4951, + "metrics": { + "B/op": 236927, + "allocs/op": 3271, + "ns/op": 294150 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-256/legacy_generic-18 \t 4951\t 294150 ns/op\t 236927 B/op\t 3271 allocs/op" + } + ], + "averageMetrics": { + "B/op": 236927, + "allocs/op": 3271, + "ns/op": 294150 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-256/current_fast_path-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 8624, + "metrics": { + "B/op": 200417, + "allocs/op": 2242, + "ns/op": 203487 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendOnlyCurrentVsLegacy/append-256/current_fast_path-18 \t 8624\t 203487 ns/op\t 200417 B/op\t 2242 allocs/op" + } + ], + "averageMetrics": { + "B/op": 200417, + "allocs/op": 2242, + "ns/op": 203487 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-32/legacy_reclone-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9558, + "metrics": { + "B/op": 272196, + "allocs/op": 1728, + "ns/op": 227147 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-32/legacy_reclone-18 \t 9558\t 227147 ns/op\t 272196 B/op\t 1728 allocs/op" + } + ], + "averageMetrics": { + "B/op": 272196, + "allocs/op": 1728, + "ns/op": 227147 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-32/current_capture_once-18", + "bucket": "memory", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 112992, + "allocs/op": 1567, + "ns/op": 124926 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-32/current_capture_once-18 \t 10000\t 124926 ns/op\t 112992 B/op\t 1567 allocs/op" + } + ], + "averageMetrics": { + "B/op": 112992, + "allocs/op": 1567, + "ns/op": 124926 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-128/legacy_reclone-18", + "bucket": "memory", + "samples": [ + { + "iterations": 4978, + "metrics": { + "B/op": 804526, + "allocs/op": 2501, + "ns/op": 508536 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-128/legacy_reclone-18 \t 4978\t 508536 ns/op\t 804526 B/op\t 2501 allocs/op" + } + ], + "averageMetrics": { + "B/op": 804526, + "allocs/op": 2501, + "ns/op": 508536 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-128/current_capture_once-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9776, + "metrics": { + "B/op": 149984, + "allocs/op": 1857, + "ns/op": 151733 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-128/current_capture_once-18 \t 9776\t 151733 ns/op\t 149984 B/op\t 1857 allocs/op" + } + ], + "averageMetrics": { + "B/op": 149984, + "allocs/op": 1857, + "ns/op": 151733 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-256/legacy_reclone-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1245, + "metrics": { + "B/op": 1633120, + "allocs/op": 3529, + "ns/op": 855267 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-256/legacy_reclone-18 \t 1245\t 855267 ns/op\t 1633120 B/op\t 3529 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1633120, + "allocs/op": 3529, + "ns/op": 855267 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-256/current_capture_once-18", + "bucket": "memory", + "samples": [ + { + "iterations": 8464, + "metrics": { + "B/op": 200416, + "allocs/op": 2242, + "ns/op": 181361 + }, + "raw": "BenchmarkCommitRegionPatchTransactionAppendSnapshotCurrentVsLegacy/append-256/current_capture_once-18 \t 8464\t 181361 ns/op\t 200416 B/op\t 2242 allocs/op" + } + ], + "averageMetrics": { + "B/op": 200416, + "allocs/op": 2242, + "ns/op": 181361 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-120/legacy_sequential-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 25501, + "metrics": { + "B/op": 51080, + "allocs/op": 282, + "ns/op": 46537 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-120/legacy_sequential-18 \t 25501\t 46537 ns/op\t 51080 B/op\t 282 allocs/op" + } + ], + "averageMetrics": { + "B/op": 51080, + "allocs/op": 282, + "ns/op": 46537 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-120/current_batched-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 24820, + "metrics": { + "B/op": 53424, + "allocs/op": 285, + "ns/op": 56402 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-120/current_batched-18 \t 24820\t 56402 ns/op\t 53424 B/op\t 285 allocs/op" + } + ], + "averageMetrics": { + "B/op": 53424, + "allocs/op": 285, + "ns/op": 56402 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-240/legacy_sequential-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 12408, + "metrics": { + "B/op": 105128, + "allocs/op": 644, + "ns/op": 98756 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-240/legacy_sequential-18 \t 12408\t 98756 ns/op\t 105128 B/op\t 644 allocs/op" + } + ], + "averageMetrics": { + "B/op": 105128, + "allocs/op": 644, + "ns/op": 98756 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-240/current_batched-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 13983, + "metrics": { + "B/op": 110032, + "allocs/op": 647, + "ns/op": 87231 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-240/current_batched-18 \t 13983\t 87231 ns/op\t 110032 B/op\t 647 allocs/op" + } + ], + "averageMetrics": { + "B/op": 110032, + "allocs/op": 647, + "ns/op": 87231 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-480/legacy_sequential-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 7087, + "metrics": { + "B/op": 201672, + "allocs/op": 1366, + "ns/op": 186641 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-480/legacy_sequential-18 \t 7087\t 186641 ns/op\t 201672 B/op\t 1366 allocs/op" + } + ], + "averageMetrics": { + "B/op": 201672, + "allocs/op": 1366, + "ns/op": 186641 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-480/current_batched-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 6214, + "metrics": { + "B/op": 211184, + "allocs/op": 1369, + "ns/op": 195781 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRemoveOnlyCurrentVsLegacy/siblings-480/current_batched-18 \t 6214\t 195781 ns/op\t 211184 B/op\t 1369 allocs/op" + } + ], + "averageMetrics": { + "B/op": 211184, + "allocs/op": 1369, + "ns/op": 195781 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRollbackCurrentVsLegacy/legacy_clone_on_restore-18", + "bucket": "memory", + "samples": [ + { + "iterations": 6520, + "metrics": { + "B/op": 271129, + "allocs/op": 2066, + "ns/op": 218870 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRollbackCurrentVsLegacy/legacy_clone_on_restore-18 \t 6520\t 218870 ns/op\t 271129 B/op\t 2066 allocs/op" + } + ], + "averageMetrics": { + "B/op": 271129, + "allocs/op": 2066, + "ns/op": 218870 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionRollbackCurrentVsLegacy/current_restore_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1397421, + "metrics": { + "B/op": 520, + "allocs/op": 9, + "ns/op": 905.5 + }, + "raw": "BenchmarkCommitRegionPatchTransactionRollbackCurrentVsLegacy/current_restore_snapshot-18 \t 1397421\t 905.5 ns/op\t 520 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 520, + "allocs/op": 9, + "ns/op": 905.5 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/insert_rollback/legacy_full_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 5059, + "metrics": { + "B/op": 312289, + "allocs/op": 2071, + "ns/op": 260988 + }, + "raw": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/insert_rollback/legacy_full_snapshot-18 \t 5059\t 260988 ns/op\t 312289 B/op\t 2071 allocs/op" + } + ], + "averageMetrics": { + "B/op": 312289, + "allocs/op": 2071, + "ns/op": 260988 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/insert_rollback/current_partial_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 51229, + "metrics": { + "B/op": 41636, + "allocs/op": 15, + "ns/op": 36839 + }, + "raw": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/insert_rollback/current_partial_snapshot-18 \t 51229\t 36839 ns/op\t 41636 B/op\t 15 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41636, + "allocs/op": 15, + "ns/op": 36839 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/move_rollback/legacy_full_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 5438, + "metrics": { + "B/op": 287591, + "allocs/op": 2066, + "ns/op": 217583 + }, + "raw": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/move_rollback/legacy_full_snapshot-18 \t 5438\t 217583 ns/op\t 287591 B/op\t 2066 allocs/op" + } + ], + "averageMetrics": { + "B/op": 287591, + "allocs/op": 2066, + "ns/op": 217583 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/move_rollback/current_partial_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 176358, + "metrics": { + "B/op": 16922, + "allocs/op": 10, + "ns/op": 9104 + }, + "raw": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/move_rollback/current_partial_snapshot-18 \t 176358\t 9104 ns/op\t 16922 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 16922, + "allocs/op": 10, + "ns/op": 9104 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/remove_rollback/legacy_full_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 4257, + "metrics": { + "B/op": 287802, + "allocs/op": 2069, + "ns/op": 282838 + }, + "raw": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/remove_rollback/legacy_full_snapshot-18 \t 4257\t 282838 ns/op\t 287802 B/op\t 2069 allocs/op" + } + ], + "averageMetrics": { + "B/op": 287802, + "allocs/op": 2069, + "ns/op": 282838 + } + }, + { + "name": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/remove_rollback/current_partial_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 3704, + "metrics": { + "B/op": 407815, + "allocs/op": 2092, + "ns/op": 430480 + }, + "raw": "BenchmarkCommitRegionPatchTransactionStructuralRollbackCurrentVsLegacy/remove_rollback/current_partial_snapshot-18 \t 3704\t 430480 ns/op\t 407815 B/op\t 2092 allocs/op" + } + ], + "averageMetrics": { + "B/op": 407815, + "allocs/op": 2092, + "ns/op": 430480 + } + }, + { + "name": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/legacy_raw_payload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 367494, + "metrics": { + "B/op": 664, + "allocs/op": 14, + "ns/op": 3265 + }, + "raw": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/legacy_raw_payload-18 \t 367494\t 3265 ns/op\t 664 B/op\t 14 allocs/op" + } + ], + "averageMetrics": { + "B/op": 664, + "allocs/op": 14, + "ns/op": 3265 + } + }, + { + "name": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/current_raw_payload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 622933, + "metrics": { + "B/op": 416, + "allocs/op": 9, + "ns/op": 1964 + }, + "raw": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/current_raw_payload-18 \t 622933\t 1964 ns/op\t 416 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 416, + "allocs/op": 9, + "ns/op": 1964 + } + }, + { + "name": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/legacy_envelope_payload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 276175, + "metrics": { + "B/op": 848, + "allocs/op": 16, + "ns/op": 4225 + }, + "raw": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/legacy_envelope_payload-18 \t 276175\t 4225 ns/op\t 848 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 848, + "allocs/op": 16, + "ns/op": 4225 + } + }, + { + "name": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/current_envelope_payload-18", + "bucket": "memory", + "samples": [ + { + "iterations": 225914, + "metrics": { + "B/op": 848, + "allocs/op": 16, + "ns/op": 4433 + }, + "raw": "BenchmarkParsePatchStreamFromStructuredClonePayloadCurrentVsLegacy/current_envelope_payload-18 \t 225914\t 4433 ns/op\t 848 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 848, + "allocs/op": 16, + "ns/op": 4433 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_primary/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 4274930, + "metrics": { + "B/op": 40, + "allocs/op": 3, + "ns/op": 294.8 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_primary/legacy-18 \t 4274930\t 294.8 ns/op\t 40 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 40, + "allocs/op": 3, + "ns/op": 294.8 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_primary/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 4274415, + "metrics": { + "B/op": 40, + "allocs/op": 3, + "ns/op": 287.6 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_primary/current-18 \t 4274415\t 287.6 ns/op\t 40 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 40, + "allocs/op": 3, + "ns/op": 287.6 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_fallback_structured/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 253333, + "metrics": { + "B/op": 904, + "allocs/op": 18, + "ns/op": 4886 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_fallback_structured/legacy-18 \t 253333\t 4886 ns/op\t 904 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 904, + "allocs/op": 18, + "ns/op": 4886 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_fallback_structured/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 263610, + "metrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4580 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/binary_fallback_structured/current-18 \t 263610\t 4580 ns/op\t 888 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4580 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_fallback_structured/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 259473, + "metrics": { + "B/op": 904, + "allocs/op": 18, + "ns/op": 4751 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_fallback_structured/legacy-18 \t 259473\t 4751 ns/op\t 904 B/op\t 18 allocs/op" + } + ], + "averageMetrics": { + "B/op": 904, + "allocs/op": 18, + "ns/op": 4751 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_fallback_structured/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 259740, + "metrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4642 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_fallback_structured/current-18 \t 259740\t 4642 ns/op\t 888 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4642 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_primary/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 256953, + "metrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4705 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_primary/legacy-18 \t 256953\t 4705 ns/op\t 888 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4705 + } + }, + { + "name": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_primary/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 250306, + "metrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4755 + }, + "raw": "BenchmarkParseHostPatchPayloadWithFallbackCurrentVsLegacy/shared_buffer_primary/current-18 \t 250306\t 4755 ns/op\t 888 B/op\t 17 allocs/op" + } + ], + "averageMetrics": { + "B/op": 888, + "allocs/op": 17, + "ns/op": 4755 + } + }, + { + "name": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/changed_payloads_legacy_sha_only-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 534625, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2699 + }, + "raw": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/changed_payloads_legacy_sha_only-18 \t 534625\t 2699 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2699 + } + }, + { + "name": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/changed_payloads_current_version_vector_gate-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 86346464, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15.02 + }, + "raw": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/changed_payloads_current_version_vector_gate-18 \t86346464\t 15.02 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15.02 + } + }, + { + "name": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/stable_payload_legacy_sha_only-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 543919, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2223 + }, + "raw": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/stable_payload_legacy_sha_only-18 \t 543919\t 2223 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2223 + } + }, + { + "name": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/stable_payload_current_digest_guard-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1429656, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 786.5 + }, + "raw": "BenchmarkHandleHostRegionDispatchHashCurrentVsLegacy/stable_payload_current_digest_guard-18 \t 1429656\t 786.5 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 786.5 + } + }, + { + "name": "BenchmarkHandleHostRegionPatchCommitAppendOnlyCurrentVsLegacyLookupDelta/legacy_build_delta_before_commit-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4846, + "metrics": { + "B/op": 384537, + "allocs/op": 1089, + "ns/op": 266243 + }, + "raw": "BenchmarkHandleHostRegionPatchCommitAppendOnlyCurrentVsLegacyLookupDelta/legacy_build_delta_before_commit-18 \t 4846\t 266243 ns/op\t 384537 B/op\t 1089 allocs/op" + } + ], + "averageMetrics": { + "B/op": 384537, + "allocs/op": 1089, + "ns/op": 266243 + } + }, + { + "name": "BenchmarkHandleHostRegionPatchCommitAppendOnlyCurrentVsLegacyLookupDelta/current_skip_delta_for_insert_only-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5348, + "metrics": { + "B/op": 343074, + "allocs/op": 1072, + "ns/op": 251527 + }, + "raw": "BenchmarkHandleHostRegionPatchCommitAppendOnlyCurrentVsLegacyLookupDelta/current_skip_delta_for_insert_only-18 \t 5348\t 251527 ns/op\t 343074 B/op\t 1072 allocs/op" + } + ], + "averageMetrics": { + "B/op": 343074, + "allocs/op": 1072, + "ns/op": 251527 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/current-stable-flat-props-wide-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1279840, + "metrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 894.3 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/current-stable-flat-props-wide-18 \t 1279840\t 894.3 ns/op\t 592 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 894.3 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/legacy-stable-flat-props-wide-18", + "bucket": "memory", + "samples": [ + { + "iterations": 907509, + "metrics": { + "B/op": 1008, + "allocs/op": 11, + "ns/op": 1298 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/legacy-stable-flat-props-wide-18 \t 907509\t 1298 ns/op\t 1008 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1008, + "allocs/op": 11, + "ns/op": 1298 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/current-changed-flat-props-wide-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1280127, + "metrics": { + "B/op": 600, + "allocs/op": 4, + "ns/op": 1007 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/current-changed-flat-props-wide-18 \t 1280127\t 1007 ns/op\t 600 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 600, + "allocs/op": 4, + "ns/op": 1007 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/legacy-changed-flat-props-wide-18", + "bucket": "memory", + "samples": [ + { + "iterations": 931893, + "metrics": { + "B/op": 1016, + "allocs/op": 11, + "ns/op": 1375 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotPropsShapeFingerprintCurrentVsLegacy/legacy-changed-flat-props-wide-18 \t 931893\t 1375 ns/op\t 1016 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1016, + "allocs/op": 11, + "ns/op": 1375 + } + }, + { + "name": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/no_change_legacy_sha_always-18", + "bucket": "memory", + "samples": [ + { + "iterations": 392636, + "metrics": { + "B/op": 1907, + "allocs/op": 20, + "ns/op": 3227 + }, + "raw": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/no_change_legacy_sha_always-18 \t 392636\t 3227 ns/op\t 1907 B/op\t 20 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1907, + "allocs/op": 20, + "ns/op": 3227 + } + }, + { + "name": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/no_change_current_fast_prefilter-18", + "bucket": "memory", + "samples": [ + { + "iterations": 3059193, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 400.2 + }, + "raw": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/no_change_current_fast_prefilter-18 \t 3059193\t 400.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 400.2 + } + }, + { + "name": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/changed_legacy_sha_always-18", + "bucket": "memory", + "samples": [ + { + "iterations": 302910, + "metrics": { + "B/op": 3598, + "allocs/op": 31, + "ns/op": 3977 + }, + "raw": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/changed_legacy_sha_always-18 \t 302910\t 3977 ns/op\t 3598 B/op\t 31 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3598, + "allocs/op": 31, + "ns/op": 3977 + } + }, + { + "name": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/changed_current_fast_prefilter-18", + "bucket": "memory", + "samples": [ + { + "iterations": 331524, + "metrics": { + "B/op": 2590, + "allocs/op": 25, + "ns/op": 4082 + }, + "raw": "BenchmarkHandleHostRegionSnapshotHashPrefilterCurrentVsLegacy/changed_current_fast_prefilter-18 \t 331524\t 4082 ns/op\t 2590 B/op\t 25 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2590, + "allocs/op": 25, + "ns/op": 4082 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateCurrentVsLegacy/current_dispatch_fields_plus_trusted_write-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 12874141, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 94.12 + }, + "raw": "BenchmarkHandleHostRegionUpdateCurrentVsLegacy/current_dispatch_fields_plus_trusted_write-18 \t12874141\t 94.12 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 94.12 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateCurrentVsLegacy/legacy_full_entry_plus_update_and_get-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10045984, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 120.8 + }, + "raw": "BenchmarkHandleHostRegionUpdateCurrentVsLegacy/legacy_full_entry_plus_update_and_get-18 \t10045984\t 120.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 120.8 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/current-changed-props-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2336548, + "metrics": { + "B/op": 600, + "allocs/op": 4, + "ns/op": 537.3 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/current-changed-props-18 \t 2336548\t 537.3 ns/op\t 600 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 600, + "allocs/op": 4, + "ns/op": 537.3 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/legacy-changed-props-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1633556, + "metrics": { + "B/op": 936, + "allocs/op": 6, + "ns/op": 748.2 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/legacy-changed-props-18 \t 1633556\t 748.2 ns/op\t 936 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 936, + "allocs/op": 6, + "ns/op": 748.2 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/current-stable-props-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2331136, + "metrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 490.9 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/current-stable-props-18 \t 2331136\t 490.9 ns/op\t 592 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 490.9 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/legacy-stable-props-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1706700, + "metrics": { + "B/op": 928, + "allocs/op": 6, + "ns/op": 757.9 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshotCurrentVsLegacy/legacy-stable-props-18 \t 1706700\t 757.9 ns/op\t 928 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 928, + "allocs/op": 6, + "ns/op": 757.9 + } + }, + { + "name": "BenchmarkHandleHostWorkerRegionUpdateOrchestrationCurrentVsLegacy/legacy_decode_every_update-18", + "bucket": "memory", + "samples": [ + { + "iterations": 91041, + "metrics": { + "B/op": 5860, + "allocs/op": 76, + "ns/op": 13556 + }, + "raw": "BenchmarkHandleHostWorkerRegionUpdateOrchestrationCurrentVsLegacy/legacy_decode_every_update-18 \t 91041\t 13556 ns/op\t 5860 B/op\t 76 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5860, + "allocs/op": 76, + "ns/op": 13556 + } + }, + { + "name": "BenchmarkHandleHostWorkerRegionUpdateOrchestrationCurrentVsLegacy/current_reuse_dispatch_snapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 139116, + "metrics": { + "B/op": 4530, + "allocs/op": 48, + "ns/op": 7509 + }, + "raw": "BenchmarkHandleHostWorkerRegionUpdateOrchestrationCurrentVsLegacy/current_reuse_dispatch_snapshot-18 \t 139116\t 7509 ns/op\t 4530 B/op\t 48 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4530, + "allocs/op": 48, + "ns/op": 7509 + } + }, + { + "name": "BenchmarkParseCanonicalRenderTree-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 61898, + "metrics": { + "B/op": 60704, + "allocs/op": 16, + "ns/op": 17385 + }, + "raw": "BenchmarkParseCanonicalRenderTree-18 \t 61898\t 17385 ns/op\t 60704 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 60704, + "allocs/op": 16, + "ns/op": 17385 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentity/small-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 120435470, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.751 + }, + "raw": "BenchmarkBuildPatchStreamIdentity/small-18 \t120435470\t 9.751 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.751 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentity/large-keyed-rotate-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 120532076, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.784 + }, + "raw": "BenchmarkBuildPatchStreamIdentity/large-keyed-rotate-18 \t120532076\t 9.784 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 9.784 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5078055, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 241.2 + }, + "raw": "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/no-change-18 \t 5078055\t 241.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 241.2 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2545226, + "metrics": { + "B/op": 344, + "allocs/op": 3, + "ns/op": 505.3 + }, + "raw": "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed-18 \t 2545226\t 505.3 ns/op\t 344 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 344, + "allocs/op": 3, + "ns/op": 505.3 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed-reused-spec-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3511266, + "metrics": { + "B/op": 8, + "allocs/op": 0, + "ns/op": 373.4 + }, + "raw": "BenchmarkHandleHostRegionUpdateDispatchWithPriorityDeferred/changed-reused-spec-18 \t 3511266\t 373.4 ns/op\t 8 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 0, + "ns/op": 373.4 + } + }, + { + "name": "BenchmarkHandleHostRegionSnapshotFingerprint/no-change-18", + "bucket": "memory", + "samples": [ + { + "iterations": 5022342, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 225.6 + }, + "raw": "BenchmarkHandleHostRegionSnapshotFingerprint/no-change-18 \t 5022342\t 225.6 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 225.6 + } + }, + { + "name": "BenchmarkHandleHostRegionSnapshotFingerprint/changed-18", + "bucket": "memory", + "samples": [ + { + "iterations": 513050, + "metrics": { + "B/op": 1548, + "allocs/op": 15, + "ns/op": 2612 + }, + "raw": "BenchmarkHandleHostRegionSnapshotFingerprint/changed-18 \t 513050\t 2612 ns/op\t 1548 B/op\t 15 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1548, + "allocs/op": 15, + "ns/op": 2612 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/small/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 89868790, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.45 + }, + "raw": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/small/current-18 \t89868790\t 13.45 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.45 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/small/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 709332, + "metrics": { + "B/op": 521, + "allocs/op": 4, + "ns/op": 1735 + }, + "raw": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/small/legacy-18 \t 709332\t 1735 ns/op\t 521 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 521, + "allocs/op": 4, + "ns/op": 1735 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/large/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 90307042, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.44 + }, + "raw": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/large/current-18 \t90307042\t 13.44 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.44 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/large/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 39427, + "metrics": { + "B/op": 8357, + "allocs/op": 4, + "ns/op": 31319 + }, + "raw": "BenchmarkBuildPatchStreamIdentityCurrentVsLegacy/large/legacy-18 \t 39427\t 31319 ns/op\t 8357 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8357, + "allocs/op": 4, + "ns/op": 31319 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/small/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 89966486, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.41 + }, + "raw": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/small/current-18 \t89966486\t 13.41 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.41 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/small/legacy-stream-writer-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 617089, + "metrics": { + "B/op": 376, + "allocs/op": 11, + "ns/op": 1946 + }, + "raw": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/small/legacy-stream-writer-18 \t 617089\t 1946 ns/op\t 376 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 376, + "allocs/op": 11, + "ns/op": 1946 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/large/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 88829011, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.43 + }, + "raw": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/large/current-18 \t88829011\t 13.43 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.43 + } + }, + { + "name": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/large/legacy-stream-writer-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 31011, + "metrics": { + "B/op": 6836, + "allocs/op": 135, + "ns/op": 36426 + }, + "raw": "BenchmarkBuildPatchStreamIdentityStreamingCurrentVsLegacy/large/legacy-stream-writer-18 \t 31011\t 36426 ns/op\t 6836 B/op\t 135 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6836, + "allocs/op": 135, + "ns/op": 36426 + } + }, + { + "name": "BenchmarkParseCanonicalRenderTreeCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 75830, + "metrics": { + "B/op": 60704, + "allocs/op": 16, + "ns/op": 19714 + }, + "raw": "BenchmarkParseCanonicalRenderTreeCurrentVsLegacy/current-18 \t 75830\t 19714 ns/op\t 60704 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 60704, + "allocs/op": 16, + "ns/op": 19714 + } + }, + { + "name": "BenchmarkParseCanonicalRenderTreeCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 68328, + "metrics": { + "B/op": 63904, + "allocs/op": 16, + "ns/op": 21576 + }, + "raw": "BenchmarkParseCanonicalRenderTreeCurrentVsLegacy/legacy-18 \t 68328\t 21576 ns/op\t 63904 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 63904, + "allocs/op": 16, + "ns/op": 21576 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-32/legacy_copy_known_nodes-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 11363, + "allocs/op": 33, + "ns/op": 109661 + }, + "raw": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-32/legacy_copy_known_nodes-18 \t 10000\t 109661 ns/op\t 11363 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 11363, + "allocs/op": 33, + "ns/op": 109661 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-32/current_overlay_validation-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 199400, + "metrics": { + "B/op": 12456, + "allocs/op": 36, + "ns/op": 6804 + }, + "raw": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-32/current_overlay_validation-18 \t 199400\t 6804 ns/op\t 12456 B/op\t 36 allocs/op" + } + ], + "averageMetrics": { + "B/op": 12456, + "allocs/op": 36, + "ns/op": 6804 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-128/legacy_copy_known_nodes-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 9846, + "metrics": { + "B/op": 41329, + "allocs/op": 129, + "ns/op": 124345 + }, + "raw": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-128/legacy_copy_known_nodes-18 \t 9846\t 124345 ns/op\t 41329 B/op\t 129 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41329, + "allocs/op": 129, + "ns/op": 124345 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-128/current_overlay_validation-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 54343, + "metrics": { + "B/op": 45864, + "allocs/op": 132, + "ns/op": 24698 + }, + "raw": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-128/current_overlay_validation-18 \t 54343\t 24698 ns/op\t 45864 B/op\t 132 allocs/op" + } + ], + "averageMetrics": { + "B/op": 45864, + "allocs/op": 132, + "ns/op": 24698 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-256/legacy_copy_known_nodes-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 8634, + "metrics": { + "B/op": 82478, + "allocs/op": 257, + "ns/op": 150959 + }, + "raw": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-256/legacy_copy_known_nodes-18 \t 8634\t 150959 ns/op\t 82478 B/op\t 257 allocs/op" + } + ], + "averageMetrics": { + "B/op": 82478, + "allocs/op": 257, + "ns/op": 150959 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-256/current_overlay_validation-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 22593, + "metrics": { + "B/op": 91432, + "allocs/op": 260, + "ns/op": 45260 + }, + "raw": "BenchmarkParsePatchStreamTransactionAppendOnlyCurrentVsLegacy/append-256/current_overlay_validation-18 \t 22593\t 45260 ns/op\t 91432 B/op\t 260 allocs/op" + } + ], + "averageMetrics": { + "B/op": 91432, + "allocs/op": 260, + "ns/op": 45260 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionCurrentVsLegacySiblingCopy/legacy_sibling_copy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 49468, + "metrics": { + "B/op": 225, + "allocs/op": 1, + "ns/op": 24494 + }, + "raw": "BenchmarkParsePatchStreamTransactionCurrentVsLegacySiblingCopy/legacy_sibling_copy-18 \t 49468\t 24494 ns/op\t 225 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 225, + "allocs/op": 1, + "ns/op": 24494 + } + }, + { + "name": "BenchmarkParsePatchStreamTransactionCurrentVsLegacySiblingCopy/current_read_only_sibling_lookup-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5871159, + "metrics": { + "B/op": 224, + "allocs/op": 1, + "ns/op": 204 + }, + "raw": "BenchmarkParsePatchStreamTransactionCurrentVsLegacySiblingCopy/current_read_only_sibling_lookup-18 \t 5871159\t 204.0 ns/op\t 224 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 224, + "allocs/op": 1, + "ns/op": 204 + } + }, + { + "name": "BenchmarkBuildCanonicalPatchKeyedMoveOpsCurrentVsLegacy/legacy_always_filter-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 15030, + "metrics": { + "B/op": 18048, + "allocs/op": 134, + "ns/op": 93997 + }, + "raw": "BenchmarkBuildCanonicalPatchKeyedMoveOpsCurrentVsLegacy/legacy_always_filter-18 \t 15030\t 93997 ns/op\t 18048 B/op\t 134 allocs/op" + } + ], + "averageMetrics": { + "B/op": 18048, + "allocs/op": 134, + "ns/op": 93997 + } + }, + { + "name": "BenchmarkBuildCanonicalPatchKeyedMoveOpsCurrentVsLegacy/current_parent_delta_filter-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 16924, + "metrics": { + "B/op": 1024, + "allocs/op": 7, + "ns/op": 69147 + }, + "raw": "BenchmarkBuildCanonicalPatchKeyedMoveOpsCurrentVsLegacy/current_parent_delta_filter-18 \t 16924\t 69147 ns/op\t 1024 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1024, + "allocs/op": 7, + "ns/op": 69147 + } + }, + { + "name": "BenchmarkParseBuildCanonicalChildrenCurrentVsLegacy/legacy_reflect_first-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 24292, + "metrics": { + "B/op": 34968, + "allocs/op": 386, + "ns/op": 49431 + }, + "raw": "BenchmarkParseBuildCanonicalChildrenCurrentVsLegacy/legacy_reflect_first-18 \t 24292\t 49431 ns/op\t 34968 B/op\t 386 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34968, + "allocs/op": 386, + "ns/op": 49431 + } + }, + { + "name": "BenchmarkParseBuildCanonicalChildrenCurrentVsLegacy/current_any_slice_fast_path-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 26632, + "metrics": { + "B/op": 34968, + "allocs/op": 386, + "ns/op": 48225 + }, + "raw": "BenchmarkParseBuildCanonicalChildrenCurrentVsLegacy/current_any_slice_fast_path-18 \t 26632\t 48225 ns/op\t 34968 B/op\t 386 allocs/op" + } + ], + "averageMetrics": { + "B/op": 34968, + "allocs/op": 386, + "ns/op": 48225 + } + }, + { + "name": "BenchmarkParseBuildCanonicalMapValueCurrentVsLegacy/legacy_map_keys-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 35248, + "metrics": { + "B/op": 33240, + "allocs/op": 517, + "ns/op": 34070 + }, + "raw": "BenchmarkParseBuildCanonicalMapValueCurrentVsLegacy/legacy_map_keys-18 \t 35248\t 34070 ns/op\t 33240 B/op\t 517 allocs/op" + } + ], + "averageMetrics": { + "B/op": 33240, + "allocs/op": 517, + "ns/op": 34070 + } + }, + { + "name": "BenchmarkParseBuildCanonicalMapValueCurrentVsLegacy/current_map_range-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 44755, + "metrics": { + "B/op": 26712, + "allocs/op": 516, + "ns/op": 29238 + }, + "raw": "BenchmarkParseBuildCanonicalMapValueCurrentVsLegacy/current_map_range-18 \t 44755\t 29238 ns/op\t 26712 B/op\t 516 allocs/op" + } + ], + "averageMetrics": { + "B/op": 26712, + "allocs/op": 516, + "ns/op": 29238 + } + }, + { + "name": "BenchmarkBuildCanonicalRenderIRCurrentVsLegacy/legacy_node_id_index_map-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1152, + "metrics": { + "B/op": 837592, + "allocs/op": 4385, + "ns/op": 1107465 + }, + "raw": "BenchmarkBuildCanonicalRenderIRCurrentVsLegacy/legacy_node_id_index_map-18 \t 1152\t 1107465 ns/op\t 837592 B/op\t 4385 allocs/op" + } + ], + "averageMetrics": { + "B/op": 837592, + "allocs/op": 4385, + "ns/op": 1107465 + } + }, + { + "name": "BenchmarkBuildCanonicalRenderIRCurrentVsLegacy/current_child_start_slice-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1327, + "metrics": { + "B/op": 673110, + "allocs/op": 4362, + "ns/op": 985348 + }, + "raw": "BenchmarkBuildCanonicalRenderIRCurrentVsLegacy/current_child_start_slice-18 \t 1327\t 985348 ns/op\t 673110 B/op\t 4362 allocs/op" + } + ], + "averageMetrics": { + "B/op": 673110, + "allocs/op": 4362, + "ns/op": 985348 + } + }, + { + "name": "BenchmarkParseBuildCanonicalChildrenIRCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 69704, + "metrics": { + "B/op": 13080, + "allocs/op": 146, + "ns/op": 17274 + }, + "raw": "BenchmarkParseBuildCanonicalChildrenIRCurrentVsLegacy/legacy-18 \t 69704\t 17274 ns/op\t 13080 B/op\t 146 allocs/op" + } + ], + "averageMetrics": { + "B/op": 13080, + "allocs/op": 146, + "ns/op": 17274 + } + }, + { + "name": "BenchmarkParseBuildCanonicalChildrenIRCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 68672, + "metrics": { + "B/op": 13080, + "allocs/op": 146, + "ns/op": 18443 + }, + "raw": "BenchmarkParseBuildCanonicalChildrenIRCurrentVsLegacy/current-18 \t 68672\t 18443 ns/op\t 13080 B/op\t 146 allocs/op" + } + ], + "averageMetrics": { + "B/op": 13080, + "allocs/op": 146, + "ns/op": 18443 + } + }, + { + "name": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/string_keys/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1474869, + "metrics": { + "B/op": 432, + "allocs/op": 8, + "ns/op": 1337 + }, + "raw": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/string_keys/legacy-18 \t 1474869\t 1337 ns/op\t 432 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 432, + "allocs/op": 8, + "ns/op": 1337 + } + }, + { + "name": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/string_keys/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1936436, + "metrics": { + "B/op": 432, + "allocs/op": 8, + "ns/op": 532.4 + }, + "raw": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/string_keys/current-18 \t 1936436\t 532.4 ns/op\t 432 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 432, + "allocs/op": 8, + "ns/op": 532.4 + } + }, + { + "name": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/numeric_keys/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1817785, + "metrics": { + "B/op": 432, + "allocs/op": 10, + "ns/op": 639.9 + }, + "raw": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/numeric_keys/legacy-18 \t 1817785\t 639.9 ns/op\t 432 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 432, + "allocs/op": 10, + "ns/op": 639.9 + } + }, + { + "name": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/numeric_keys/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1997154, + "metrics": { + "B/op": 432, + "allocs/op": 10, + "ns/op": 562.7 + }, + "raw": "BenchmarkParseBuildCanonicalMapValueIRCurrentVsLegacy/numeric_keys/current-18 \t 1997154\t 562.7 ns/op\t 432 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 432, + "allocs/op": 10, + "ns/op": 562.7 + } + }, + { + "name": "BenchmarkParseBuildCanonicalRenderNodeCurrentVsLegacy/legacy_kind_tag_normalization-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 34314, + "metrics": { + "B/op": 23120, + "allocs/op": 344, + "ns/op": 33062 + }, + "raw": "BenchmarkParseBuildCanonicalRenderNodeCurrentVsLegacy/legacy_kind_tag_normalization-18 \t 34314\t 33062 ns/op\t 23120 B/op\t 344 allocs/op" + } + ], + "averageMetrics": { + "B/op": 23120, + "allocs/op": 344, + "ns/op": 33062 + } + }, + { + "name": "BenchmarkParseBuildCanonicalRenderNodeCurrentVsLegacy/current_kind_tag_fast_path-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 36657, + "metrics": { + "B/op": 23120, + "allocs/op": 344, + "ns/op": 34026 + }, + "raw": "BenchmarkParseBuildCanonicalRenderNodeCurrentVsLegacy/current_kind_tag_fast_path-18 \t 36657\t 34026 ns/op\t 23120 B/op\t 344 allocs/op" + } + ], + "averageMetrics": { + "B/op": 23120, + "allocs/op": 344, + "ns/op": 34026 + } + }, + { + "name": "BenchmarkParseRenderNodeTableCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 146094, + "metrics": { + "B/op": 15528, + "allocs/op": 5, + "ns/op": 8969 + }, + "raw": "BenchmarkParseRenderNodeTableCurrentVsLegacy/current-18 \t 146094\t 8969 ns/op\t 15528 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 15528, + "allocs/op": 5, + "ns/op": 8969 + } + }, + { + "name": "BenchmarkParseRenderNodeTableCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 150052, + "metrics": { + "B/op": 15528, + "allocs/op": 5, + "ns/op": 8912 + }, + "raw": "BenchmarkParseRenderNodeTableCurrentVsLegacy/legacy-18 \t 150052\t 8912 ns/op\t 15528 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 15528, + "allocs/op": 5, + "ns/op": 8912 + } + }, + { + "name": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/single_prop/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3781254, + "metrics": { + "B/op": 72, + "allocs/op": 2, + "ns/op": 323.3 + }, + "raw": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/single_prop/legacy-18 \t 3781254\t 323.3 ns/op\t 72 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 72, + "allocs/op": 2, + "ns/op": 323.3 + } + }, + { + "name": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/single_prop/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5916531, + "metrics": { + "B/op": 48, + "allocs/op": 1, + "ns/op": 216.5 + }, + "raw": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/single_prop/current-18 \t 5916531\t 216.5 ns/op\t 48 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 1, + "ns/op": 216.5 + } + }, + { + "name": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/many_props/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 408, + "allocs/op": 9, + "ns/op": 1168 + }, + "raw": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/many_props/legacy-18 \t 1000000\t 1168 ns/op\t 408 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 408, + "allocs/op": 9, + "ns/op": 1168 + } + }, + { + "name": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/many_props/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 408, + "allocs/op": 9, + "ns/op": 1043 + }, + "raw": "BenchmarkParseBuildCanonicalPropsCurrentVsLegacy/many_props/current-18 \t 1000000\t 1043 ns/op\t 408 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 408, + "allocs/op": 9, + "ns/op": 1043 + } + }, + { + "name": "BenchmarkBuildRenderStringTableCurrentVsLegacy/tiny_table/legacy_always_sort-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 33101620, + "metrics": { + "B/op": 16, + "allocs/op": 1, + "ns/op": 35.88 + }, + "raw": "BenchmarkBuildRenderStringTableCurrentVsLegacy/tiny_table/legacy_always_sort-18 \t33101620\t 35.88 ns/op\t 16 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 16, + "allocs/op": 1, + "ns/op": 35.88 + } + }, + { + "name": "BenchmarkBuildRenderStringTableCurrentVsLegacy/tiny_table/current_fast_path-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 36451118, + "metrics": { + "B/op": 16, + "allocs/op": 1, + "ns/op": 30.45 + }, + "raw": "BenchmarkBuildRenderStringTableCurrentVsLegacy/tiny_table/current_fast_path-18 \t36451118\t 30.45 ns/op\t 16 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 16, + "allocs/op": 1, + "ns/op": 30.45 + } + }, + { + "name": "BenchmarkBuildRenderStringTableCurrentVsLegacy/large_table/legacy_second_pass_map-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6794, + "metrics": { + "B/op": 60120, + "allocs/op": 5, + "ns/op": 191932 + }, + "raw": "BenchmarkBuildRenderStringTableCurrentVsLegacy/large_table/legacy_second_pass_map-18 \t 6794\t 191932 ns/op\t 60120 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 60120, + "allocs/op": 5, + "ns/op": 191932 + } + }, + { + "name": "BenchmarkBuildRenderStringTableCurrentVsLegacy/large_table/current_map_build-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6604, + "metrics": { + "B/op": 60120, + "allocs/op": 5, + "ns/op": 176664 + }, + "raw": "BenchmarkBuildRenderStringTableCurrentVsLegacy/large_table/current_map_build-18 \t 6604\t 176664 ns/op\t 60120 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 60120, + "allocs/op": 5, + "ns/op": 176664 + } + }, + { + "name": "BenchmarkGetRenderStringRefCurrentVsLegacy/small_table/legacy_binary-18", + "bucket": "memory", + "samples": [ + { + "iterations": 91942749, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.4 + }, + "raw": "BenchmarkGetRenderStringRefCurrentVsLegacy/small_table/legacy_binary-18 \t91942749\t 13.40 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 13.4 + } + }, + { + "name": "BenchmarkGetRenderStringRefCurrentVsLegacy/small_table/current_inline_linear-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 100000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.82 + }, + "raw": "BenchmarkGetRenderStringRefCurrentVsLegacy/small_table/current_inline_linear-18 \t100000000\t 11.82 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.82 + } + }, + { + "name": "BenchmarkGetRenderStringRefCurrentVsLegacy/large_table/legacy_binary-18", + "bucket": "memory", + "samples": [ + { + "iterations": 33560988, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 36.34 + }, + "raw": "BenchmarkGetRenderStringRefCurrentVsLegacy/large_table/legacy_binary-18 \t33560988\t 36.34 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 36.34 + } + }, + { + "name": "BenchmarkGetRenderStringRefCurrentVsLegacy/large_table/current_binary-18", + "bucket": "memory", + "samples": [ + { + "iterations": 33667671, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 35.97 + }, + "raw": "BenchmarkGetRenderStringRefCurrentVsLegacy/large_table/current_binary-18 \t33667671\t 35.97 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 35.97 + } + }, + { + "name": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/append_distinct_updates_legacy-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 5903126, + "metrics": { + "B/op": 273, + "allocs/op": 0, + "ns/op": 199.5 + }, + "raw": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/append_distinct_updates_legacy-18 \t 5903126\t 199.5 ns/op\t 273 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 273, + "allocs/op": 0, + "ns/op": 199.5 + } + }, + { + "name": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/append_distinct_updates_current-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 8001109, + "metrics": { + "B/op": 145, + "allocs/op": 0, + "ns/op": 150.4 + }, + "raw": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/append_distinct_updates_current-18 \t 8001109\t 150.4 ns/op\t 145 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 145, + "allocs/op": 0, + "ns/op": 150.4 + } + }, + { + "name": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/equivalent_queued_updates_legacy-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 28067614, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 43.41 + }, + "raw": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/equivalent_queued_updates_legacy-18 \t28067614\t 43.41 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 43.41 + } + }, + { + "name": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/equivalent_queued_updates_current-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 30368290, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 39.88 + }, + "raw": "BenchmarkHandleSchedulerUpdateCurrentVsLegacy/equivalent_queued_updates_current-18 \t30368290\t 39.88 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 39.88 + } + }, + { + "name": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_string_map/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 13946611, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 87.84 + }, + "raw": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_string_map/current-18 \t13946611\t 87.84 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 87.84 + } + }, + { + "name": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_string_map/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3265755, + "metrics": { + "B/op": 128, + "allocs/op": 8, + "ns/op": 386 + }, + "raw": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_string_map/legacy-18 \t 3265755\t 386.0 ns/op\t 128 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 128, + "allocs/op": 8, + "ns/op": 386 + } + }, + { + "name": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_int_slice/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 41871370, + "metrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 29.59 + }, + "raw": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_int_slice/current-18 \t41871370\t 29.59 ns/op\t 24 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 29.59 + } + }, + { + "name": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_int_slice/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 14740765, + "metrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 84.2 + }, + "raw": "BenchmarkValidateSerializablePropsCurrentVsLegacy/typed_int_slice/legacy-18 \t14740765\t 84.20 ns/op\t 24 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 84.2 + } + }, + { + "name": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/medium-64/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3425716, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 351.3 + }, + "raw": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/medium-64/current-18 \t 3425716\t 351.3 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 351.3 + } + }, + { + "name": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/medium-64/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 327351, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3728 + }, + "raw": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/medium-64/legacy-18 \t 327351\t 3728 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3728 + } + }, + { + "name": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/large-512/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 71882, + "metrics": { + "B/op": 41000, + "allocs/op": 3, + "ns/op": 20076 + }, + "raw": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/large-512/current-18 \t 71882\t 20076 ns/op\t 41000 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 41000, + "allocs/op": 3, + "ns/op": 20076 + } + }, + { + "name": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/large-512/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5340, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 224496 + }, + "raw": "BenchmarkParseRenderNodeSiblingKeysCurrentVsLegacy/large-512/legacy-18 \t 5340\t 224496 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 224496 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchFastHashCurrentVsLegacy/current_streamed_maphash-18", + "bucket": "memory", + "samples": [ + { + "iterations": 849171, + "metrics": { + "B/op": 104, + "allocs/op": 3, + "ns/op": 1451 + }, + "raw": "BenchmarkBuildSnapshotDispatchFastHashCurrentVsLegacy/current_streamed_maphash-18 \t 849171\t 1451 ns/op\t 104 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 104, + "allocs/op": 3, + "ns/op": 1451 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchFastHashCurrentVsLegacy/legacy_buffered_fnv1a-18", + "bucket": "memory", + "samples": [ + { + "iterations": 900745, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1334 + }, + "raw": "BenchmarkBuildSnapshotDispatchFastHashCurrentVsLegacy/legacy_buffered_fnv1a-18 \t 900745\t 1334 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1334 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchHashCurrentVsLegacy/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 293971, + "metrics": { + "B/op": 1082, + "allocs/op": 12, + "ns/op": 4005 + }, + "raw": "BenchmarkBuildSnapshotDispatchHashCurrentVsLegacy/current-18 \t 293971\t 4005 ns/op\t 1082 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1082, + "allocs/op": 12, + "ns/op": 4005 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchHashCurrentVsLegacy/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 321394, + "metrics": { + "B/op": 1665, + "allocs/op": 3, + "ns/op": 3805 + }, + "raw": "BenchmarkBuildSnapshotDispatchHashCurrentVsLegacy/legacy-18 \t 321394\t 3805 ns/op\t 1665 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1665, + "allocs/op": 3, + "ns/op": 3805 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchFastHashPropKeysCurrentVsLegacy/legacy_sort_props_each_call-18", + "bucket": "memory", + "samples": [ + { + "iterations": 875164, + "metrics": { + "B/op": 104, + "allocs/op": 3, + "ns/op": 1412 + }, + "raw": "BenchmarkBuildSnapshotDispatchFastHashPropKeysCurrentVsLegacy/legacy_sort_props_each_call-18 \t 875164\t 1412 ns/op\t 104 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 104, + "allocs/op": 3, + "ns/op": 1412 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchFastHashPropKeysCurrentVsLegacy/current_cached_props_order-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1467831, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 828.4 + }, + "raw": "BenchmarkBuildSnapshotDispatchFastHashPropKeysCurrentVsLegacy/current_cached_props_order-18 \t 1467831\t 828.4 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 828.4 + } + }, + { + "name": "BenchmarkSnapshotDispatchPropLayoutCurrentVsEntries/current_map_iterate_sort_each_call-18", + "bucket": "memory", + "samples": [ + { + "iterations": 3009838, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 397.7 + }, + "raw": "BenchmarkSnapshotDispatchPropLayoutCurrentVsEntries/current_map_iterate_sort_each_call-18 \t 3009838\t 397.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 397.7 + } + }, + { + "name": "BenchmarkSnapshotDispatchPropLayoutCurrentVsEntries/candidate_sorted_entries_slice_scan-18", + "bucket": "memory", + "samples": [ + { + "iterations": 13475348, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 85.06 + }, + "raw": "BenchmarkSnapshotDispatchPropLayoutCurrentVsEntries/candidate_sorted_entries_slice_scan-18 \t13475348\t 85.06 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 85.06 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchFastHashPropLayoutCurrentVsKeys/current_cached_props_keys-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1513358, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 802 + }, + "raw": "BenchmarkBuildSnapshotDispatchFastHashPropLayoutCurrentVsKeys/current_cached_props_keys-18 \t 1513358\t 802.0 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 802 + } + }, + { + "name": "BenchmarkBuildSnapshotDispatchFastHashPropLayoutCurrentVsKeys/current_compact_prop_entries-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1776433, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 682.5 + }, + "raw": "BenchmarkBuildSnapshotDispatchFastHashPropLayoutCurrentVsKeys/current_compact_prop_entries-18 \t 1776433\t 682.5 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 682.5 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_rich/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 833031, + "metrics": { + "B/op": 704, + "allocs/op": 15, + "ns/op": 1460 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_rich/legacy-18 \t 833031\t 1460 ns/op\t 704 B/op\t 15 allocs/op" + } + ], + "averageMetrics": { + "B/op": 704, + "allocs/op": 15, + "ns/op": 1460 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_rich/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 867232, + "metrics": { + "B/op": 624, + "allocs/op": 14, + "ns/op": 1501 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_rich/current-18 \t 867232\t 1501 ns/op\t 624 B/op\t 14 allocs/op" + } + ], + "averageMetrics": { + "B/op": 624, + "allocs/op": 14, + "ns/op": 1501 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_header_only/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 10212747, + "metrics": { + "B/op": 112, + "allocs/op": 1, + "ns/op": 121 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_header_only/legacy-18 \t10212747\t 121.0 ns/op\t 112 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 112, + "allocs/op": 1, + "ns/op": 121 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_header_only/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9487208, + "metrics": { + "B/op": 112, + "allocs/op": 1, + "ns/op": 126.6 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/build_header_only/current-18 \t 9487208\t 126.6 ns/op\t 112 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 112, + "allocs/op": 1, + "ns/op": 126.6 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_header_only/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 12679359, + "metrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 95.45 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_header_only/legacy-18 \t12679359\t 95.45 ns/op\t 8 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 95.45 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_header_only/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 11551144, + "metrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 95.11 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_header_only/current-18 \t11551144\t 95.11 ns/op\t 8 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 95.11 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_rich/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 396158, + "metrics": { + "B/op": 1152, + "allocs/op": 28, + "ns/op": 3303 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_rich/legacy-18 \t 396158\t 3303 ns/op\t 1152 B/op\t 28 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1152, + "allocs/op": 28, + "ns/op": 3303 + } + }, + { + "name": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_rich/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 391304, + "metrics": { + "B/op": 1152, + "allocs/op": 28, + "ns/op": 3155 + }, + "raw": "BenchmarkStructuredCloneSnapshotEnvelopeCurrentVsLegacy/parse_rich/current-18 \t 391304\t 3155 ns/op\t 1152 B/op\t 28 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1152, + "allocs/op": 28, + "ns/op": 3155 + } + }, + { + "name": "BenchmarkParseRuntimeHasTrimmedNonWhitespaceTextCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 271510780, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.584 + }, + "raw": "BenchmarkParseRuntimeHasTrimmedNonWhitespaceTextCurrentVsLegacy/current-18 \t271510780\t 4.584 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.584 + } + }, + { + "name": "BenchmarkParseRuntimeHasTrimmedNonWhitespaceTextCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 260951935, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.723 + }, + "raw": "BenchmarkParseRuntimeHasTrimmedNonWhitespaceTextCurrentVsLegacy/legacy-18 \t260951935\t 4.723 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.723 + } + }, + { + "name": "BenchmarkBuildWorkerRegionUpdatePatchCurrentVsLegacy/legacy_build_canonical_patch_stream-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 332080, + "metrics": { + "B/op": 4890, + "allocs/op": 28, + "ns/op": 4092 + }, + "raw": "BenchmarkBuildWorkerRegionUpdatePatchCurrentVsLegacy/legacy_build_canonical_patch_stream-18 \t 332080\t 4092 ns/op\t 4890 B/op\t 28 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4890, + "allocs/op": 28, + "ns/op": 4092 + } + }, + { + "name": "BenchmarkBuildWorkerRegionUpdatePatchCurrentVsLegacy/current_worker_update_patch_builder-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 687363, + "metrics": { + "B/op": 2060, + "allocs/op": 12, + "ns/op": 1785 + }, + "raw": "BenchmarkBuildWorkerRegionUpdatePatchCurrentVsLegacy/current_worker_update_patch_builder-18 \t 687363\t 1785 ns/op\t 2060 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2060, + "allocs/op": 12, + "ns/op": 1785 + } + }, + { + "name": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/legacy_rebuild_order_each_call-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1307662, + "metrics": { + "B/op": 640, + "allocs/op": 4, + "ns/op": 886.2 + }, + "raw": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/legacy_rebuild_order_each_call-18 \t 1307662\t 886.2 ns/op\t 640 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 640, + "allocs/op": 4, + "ns/op": 886.2 + } + }, + { + "name": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/current_rebuild_order_each_call-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1667182, + "metrics": { + "B/op": 384, + "allocs/op": 2, + "ns/op": 754.2 + }, + "raw": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/current_rebuild_order_each_call-18 \t 1667182\t 754.2 ns/op\t 384 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 384, + "allocs/op": 2, + "ns/op": 754.2 + } + }, + { + "name": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/legacy_reuse_cached_order-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2932182, + "metrics": { + "B/op": 256, + "allocs/op": 1, + "ns/op": 411.5 + }, + "raw": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/legacy_reuse_cached_order-18 \t 2932182\t 411.5 ns/op\t 256 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 256, + "allocs/op": 1, + "ns/op": 411.5 + } + }, + { + "name": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/current_reuse_cached_order-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3112578, + "metrics": { + "B/op": 256, + "allocs/op": 1, + "ns/op": 387.4 + }, + "raw": "BenchmarkBuildWorkerRenderInputSourceOrderCurrentVsLegacy/current_reuse_cached_order-18 \t 3112578\t 387.4 ns/op\t 256 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 256, + "allocs/op": 1, + "ns/op": 387.4 + } + }, + { + "name": "BenchmarkHasRendererFeatureFlagCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6963614, + "metrics": { + "B/op": 21, + "allocs/op": 1, + "ns/op": 174.9 + }, + "raw": "BenchmarkHasRendererFeatureFlagCurrentVsLegacy/legacy-18 \t 6963614\t 174.9 ns/op\t 21 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 21, + "allocs/op": 1, + "ns/op": 174.9 + } + }, + { + "name": "BenchmarkHasRendererFeatureFlagCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 7217324, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 183.9 + }, + "raw": "BenchmarkHasRendererFeatureFlagCurrentVsLegacy/current-18 \t 7217324\t 183.9 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 183.9 + } + }, + { + "name": "BenchmarkFormatRenderStyleScalarCurrentVsLegacy/legacy-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 11121696, + "metrics": { + "B/op": 9, + "allocs/op": 1, + "ns/op": 118.4 + }, + "raw": "BenchmarkFormatRenderStyleScalarCurrentVsLegacy/legacy-18 \t11121696\t 118.4 ns/op\t 9 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9, + "allocs/op": 1, + "ns/op": 118.4 + } + }, + { + "name": "BenchmarkFormatRenderStyleScalarCurrentVsLegacy/current-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 15770611, + "metrics": { + "B/op": 4, + "allocs/op": 0, + "ns/op": 81.94 + }, + "raw": "BenchmarkFormatRenderStyleScalarCurrentVsLegacy/current-18 \t15770611\t 81.94 ns/op\t 4 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4, + "allocs/op": 0, + "ns/op": 81.94 + } + }, + { + "name": "BenchmarkFormatSchedulerShardIDCurrentVsLegacy/legacy-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 10674544, + "metrics": { + "B/op": 13, + "allocs/op": 1, + "ns/op": 112.4 + }, + "raw": "BenchmarkFormatSchedulerShardIDCurrentVsLegacy/legacy-18 \t10674544\t 112.4 ns/op\t 13 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 13, + "allocs/op": 1, + "ns/op": 112.4 + } + }, + { + "name": "BenchmarkFormatSchedulerShardIDCurrentVsLegacy/current-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 42706623, + "metrics": { + "B/op": 10, + "allocs/op": 1, + "ns/op": 28.73 + }, + "raw": "BenchmarkFormatSchedulerShardIDCurrentVsLegacy/current-18 \t42706623\t 28.73 ns/op\t 10 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 10, + "allocs/op": 1, + "ns/op": 28.73 + } + }, + { + "name": "BenchmarkAppendSnapshotDispatchAnyMapCurrentVsLegacy/legacy_allocating_entries-18", + "bucket": "memory", + "samples": [ + { + "iterations": 702291, + "metrics": { + "B/op": 488, + "allocs/op": 4, + "ns/op": 1743 + }, + "raw": "BenchmarkAppendSnapshotDispatchAnyMapCurrentVsLegacy/legacy_allocating_entries-18 \t 702291\t 1743 ns/op\t 488 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 488, + "allocs/op": 4, + "ns/op": 1743 + } + }, + { + "name": "BenchmarkAppendSnapshotDispatchAnyMapCurrentVsLegacy/current_pooled_entries-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1111 + }, + "raw": "BenchmarkAppendSnapshotDispatchAnyMapCurrentVsLegacy/current_pooled_entries-18 \t 1000000\t 1111 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1111 + } + }, + { + "name": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_string_map/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 4594575, + "metrics": { + "B/op": 64, + "allocs/op": 4, + "ns/op": 254 + }, + "raw": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_string_map/current-18 \t 4594575\t 254.0 ns/op\t 64 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 64, + "allocs/op": 4, + "ns/op": 254 + } + }, + { + "name": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_string_map/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2262524, + "metrics": { + "B/op": 288, + "allocs/op": 9, + "ns/op": 520 + }, + "raw": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_string_map/legacy-18 \t 2262524\t 520.0 ns/op\t 288 B/op\t 9 allocs/op" + } + ], + "averageMetrics": { + "B/op": 288, + "allocs/op": 9, + "ns/op": 520 + } + }, + { + "name": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_int_slice/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 12792616, + "metrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 102.1 + }, + "raw": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_int_slice/current-18 \t12792616\t 102.1 ns/op\t 24 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 102.1 + } + }, + { + "name": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_int_slice/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9105750, + "metrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 123.9 + }, + "raw": "BenchmarkAppendSnapshotDispatchValueTypedScalarContainersCurrentVsLegacy/typed_int_slice/legacy-18 \t 9105750\t 123.9 ns/op\t 24 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 123.9 + } + }, + { + "name": "BenchmarkBuildStructuredCloneSnapshotEnvelopeJSON-18", + "bucket": "memory", + "samples": [ + { + "iterations": 826110, + "metrics": { + "B/op": 624, + "allocs/op": 14, + "ns/op": 1504 + }, + "raw": "BenchmarkBuildStructuredCloneSnapshotEnvelopeJSON-18 \t 826110\t 1504 ns/op\t 624 B/op\t 14 allocs/op" + } + ], + "averageMetrics": { + "B/op": 624, + "allocs/op": 14, + "ns/op": 1504 + } + }, + { + "name": "BenchmarkHandleWorkerRegionUpdateSnapshotDrivenVsMetadataOnly/snapshot-driven-18", + "bucket": "memory", + "samples": [ + { + "iterations": 400370, + "metrics": { + "B/op": 3026, + "allocs/op": 26, + "ns/op": 3959 + }, + "raw": "BenchmarkHandleWorkerRegionUpdateSnapshotDrivenVsMetadataOnly/snapshot-driven-18 \t 400370\t 3959 ns/op\t 3026 B/op\t 26 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3026, + "allocs/op": 26, + "ns/op": 3959 + } + }, + { + "name": "BenchmarkHandleWorkerRegionUpdateSnapshotDrivenVsMetadataOnly/metadata-only-18", + "bucket": "memory", + "samples": [ + { + "iterations": 415602, + "metrics": { + "B/op": 2664, + "allocs/op": 22, + "ns/op": 3027 + }, + "raw": "BenchmarkHandleWorkerRegionUpdateSnapshotDrivenVsMetadataOnly/metadata-only-18 \t 415602\t 3027 ns/op\t 2664 B/op\t 22 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2664, + "allocs/op": 22, + "ns/op": 3027 + } + }, + { + "name": "BenchmarkBuildAndParseBinarySnapshotEnvelope/build-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 352, + "MB/s": 222.62, + "allocs/op": 1, + "ns/op": 1231 + }, + "raw": "BenchmarkBuildAndParseBinarySnapshotEnvelope/build-18 \t 1000000\t 1231 ns/op\t 222.62 MB/s\t 352 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 352, + "MB/s": 222.62, + "allocs/op": 1, + "ns/op": 1231 + } + }, + { + "name": "BenchmarkBuildAndParseBinarySnapshotEnvelope/parse-18", + "bucket": "memory", + "samples": [ + { + "iterations": 684427, + "metrics": { + "B/op": 1945, + "MB/s": 128.57, + "allocs/op": 35, + "ns/op": 2131 + }, + "raw": "BenchmarkBuildAndParseBinarySnapshotEnvelope/parse-18 \t 684427\t 2131 ns/op\t 128.57 MB/s\t 1945 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1945, + "MB/s": 128.57, + "allocs/op": 35, + "ns/op": 2131 + } + }, + { + "name": "BenchmarkBuildAndParseBinaryMountEnvelope/build-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 384, + "MB/s": 270.5, + "allocs/op": 2, + "ns/op": 1006 + }, + "raw": "BenchmarkBuildAndParseBinaryMountEnvelope/build-18 \t 1000000\t 1006 ns/op\t 270.50 MB/s\t 384 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 384, + "MB/s": 270.5, + "allocs/op": 2, + "ns/op": 1006 + } + }, + { + "name": "BenchmarkBuildAndParseBinaryMountEnvelope/parse-18", + "bucket": "memory", + "samples": [ + { + "iterations": 829095, + "metrics": { + "B/op": 1625, + "MB/s": 164.75, + "allocs/op": 32, + "ns/op": 1651 + }, + "raw": "BenchmarkBuildAndParseBinaryMountEnvelope/parse-18 \t 829095\t 1651 ns/op\t 164.75 MB/s\t 1625 B/op\t 32 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1625, + "MB/s": 164.75, + "allocs/op": 32, + "ns/op": 1651 + } + }, + { + "name": "BenchmarkBuildAndParseBinaryUpdateEnvelope/build-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2027144, + "metrics": { + "B/op": 224, + "MB/s": 242.37, + "allocs/op": 1, + "ns/op": 635.4 + }, + "raw": "BenchmarkBuildAndParseBinaryUpdateEnvelope/build-18 \t 2027144\t 635.4 ns/op\t 242.37 MB/s\t 224 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 224, + "MB/s": 242.37, + "allocs/op": 1, + "ns/op": 635.4 + } + }, + { + "name": "BenchmarkBuildAndParseBinaryUpdateEnvelope/parse-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1478800, + "metrics": { + "B/op": 760, + "MB/s": 203.38, + "allocs/op": 13, + "ns/op": 757.2 + }, + "raw": "BenchmarkBuildAndParseBinaryUpdateEnvelope/parse-18 \t 1478800\t 757.2 ns/op\t 203.38 MB/s\t 760 B/op\t 13 allocs/op" + } + ], + "averageMetrics": { + "B/op": 760, + "MB/s": 203.38, + "allocs/op": 13, + "ns/op": 757.2 + } + }, + { + "name": "BenchmarkParseBinarySnapshotEnvelopeSourceHeavy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 298701, + "metrics": { + "B/op": 3299, + "MB/s": 148.87, + "allocs/op": 67, + "ns/op": 3688 + }, + "raw": "BenchmarkParseBinarySnapshotEnvelopeSourceHeavy-18 \t 298701\t 3688 ns/op\t 148.87 MB/s\t 3299 B/op\t 67 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3299, + "MB/s": 148.87, + "allocs/op": 67, + "ns/op": 3688 + } + }, + { + "name": "BenchmarkBuildBinarySourceValueAnyMapFastPath-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2347063, + "metrics": { + "B/op": 368, + "allocs/op": 3, + "ns/op": 485.5 + }, + "raw": "BenchmarkBuildBinarySourceValueAnyMapFastPath-18 \t 2347063\t 485.5 ns/op\t 368 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 368, + "allocs/op": 3, + "ns/op": 485.5 + } + }, + { + "name": "BenchmarkParseBinarySourceIDTableCanonical-18", + "bucket": "memory", + "samples": [ + { + "iterations": 5097135, + "metrics": { + "B/op": 144, + "MB/s": 248.75, + "allocs/op": 6, + "ns/op": 241.2 + }, + "raw": "BenchmarkParseBinarySourceIDTableCanonical-18 \t 5097135\t 241.2 ns/op\t 248.75 MB/s\t 144 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 144, + "MB/s": 248.75, + "allocs/op": 6, + "ns/op": 241.2 + } + }, + { + "name": "BenchmarkGetCapabilityReport/initialized-lock-free-read-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 268377843, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.491 + }, + "raw": "BenchmarkGetCapabilityReport/initialized-lock-free-read-18 \t268377843\t 4.491 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.491 + } + }, + { + "name": "BenchmarkGetCapabilityReport/uninitialized-default-read-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 357102895, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.439 + }, + "raw": "BenchmarkGetCapabilityReport/uninitialized-default-read-18 \t357102895\t 3.439 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3.439 + } + }, + { + "name": "BenchmarkCoordinatorDispatchTransactionCurrentVsLegacy/legacy_split_snapshot_and_dispatch-18", + "bucket": "memory", + "samples": [ + { + "iterations": 20346292, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 59.51 + }, + "raw": "BenchmarkCoordinatorDispatchTransactionCurrentVsLegacy/legacy_split_snapshot_and_dispatch-18 \t20346292\t 59.51 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 59.51 + } + }, + { + "name": "BenchmarkCoordinatorDispatchTransactionCurrentVsLegacy/current_single_snapshot_and_dispatch-18", + "bucket": "memory", + "samples": [ + { + "iterations": 31358857, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 36.53 + }, + "raw": "BenchmarkCoordinatorDispatchTransactionCurrentVsLegacy/current_single_snapshot_and_dispatch-18 \t31358857\t 36.53 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 36.53 + } + }, + { + "name": "BenchmarkCoordinatorSnapshotStateCurrentVsLegacy/legacy_split_snapshot_and_sources-18", + "bucket": "memory", + "samples": [ + { + "iterations": 7671378, + "metrics": { + "B/op": 48, + "allocs/op": 1, + "ns/op": 167.8 + }, + "raw": "BenchmarkCoordinatorSnapshotStateCurrentVsLegacy/legacy_split_snapshot_and_sources-18 \t 7671378\t 167.8 ns/op\t 48 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 1, + "ns/op": 167.8 + } + }, + { + "name": "BenchmarkCoordinatorSnapshotStateCurrentVsLegacy/current_single_snapshot_and_sources-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9017322, + "metrics": { + "B/op": 48, + "allocs/op": 1, + "ns/op": 134.5 + }, + "raw": "BenchmarkCoordinatorSnapshotStateCurrentVsLegacy/current_single_snapshot_and_sources-18 \t 9017322\t 134.5 ns/op\t 48 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 1, + "ns/op": 134.5 + } + }, + { + "name": "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers-18", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 71775, + "metrics": { + "B/op": 383, + "allocs/op": 47, + "dispatch-batch-p50-ns": 15917, + "dispatch-batch-p95-ns": 39162, + "dispatch-batch-p99-ns": 78229, + "dispatch-batch-samples": 1122, + "ns/op": 17427 + }, + "raw": "BenchmarkHandleHostRegionManyHotRegionsBoundedWorkers-18 \t 71775\t 17427 ns/op\t 15917 dispatch-batch-p50-ns\t 39162 dispatch-batch-p95-ns\t 78229 dispatch-batch-p99-ns\t 1122 dispatch-batch-samples\t 383 B/op\t 47 allocs/op" + } + ], + "averageMetrics": { + "B/op": 383, + "allocs/op": 47, + "dispatch-batch-p50-ns": 15917, + "dispatch-batch-p95-ns": 39162, + "dispatch-batch-p99-ns": 78229, + "dispatch-batch-samples": 1122, + "ns/op": 17427 + } + }, + { + "name": "BenchmarkHandleHostRegionUpdateSnapshot-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2407438, + "metrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 502.9 + }, + "raw": "BenchmarkHandleHostRegionUpdateSnapshot-18 \t 2407438\t 502.9 ns/op\t 592 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 592, + "allocs/op": 4, + "ns/op": 502.9 + } + }, + { + "name": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/small/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 746299, + "metrics": { + "B/op": 1010, + "allocs/op": 8, + "ns/op": 1588 + }, + "raw": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/small/current-18 \t 746299\t 1588 ns/op\t 1010 B/op\t 8 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1010, + "allocs/op": 8, + "ns/op": 1588 + } + }, + { + "name": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/small/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 937752, + "metrics": { + "B/op": 256, + "allocs/op": 5, + "ns/op": 1256 + }, + "raw": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/small/legacy-18 \t 937752\t 1256 ns/op\t 256 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 256, + "allocs/op": 5, + "ns/op": 1256 + } + }, + { + "name": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/large/current-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9979, + "metrics": { + "B/op": 30187, + "allocs/op": 932, + "ns/op": 132287 + }, + "raw": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/large/current-18 \t 9979\t 132287 ns/op\t 30187 B/op\t 932 allocs/op" + } + ], + "averageMetrics": { + "B/op": 30187, + "allocs/op": 932, + "ns/op": 132287 + } + }, + { + "name": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/large/legacy-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9535, + "metrics": { + "B/op": 35505, + "allocs/op": 927, + "ns/op": 134771 + }, + "raw": "BenchmarkGetSnapshotFingerprintHashCurrentVsLegacy/large/legacy-18 \t 9535\t 134771 ns/op\t 35505 B/op\t 927 allocs/op" + } + ], + "averageMetrics": { + "B/op": 35505, + "allocs/op": 927, + "ns/op": 134771 + } + }, + { + "name": "BenchmarkHandleSharedSnapshotPublishAndRead/publish-18", + "bucket": "memory", + "samples": [ + { + "iterations": 67434672, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.14 + }, + "raw": "BenchmarkHandleSharedSnapshotPublishAndRead/publish-18 \t67434672\t 18.14 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.14 + } + }, + { + "name": "BenchmarkHandleSharedSnapshotPublishAndRead/read-18", + "bucket": "memory", + "samples": [ + { + "iterations": 20138788, + "metrics": { + "B/op": 96, + "allocs/op": 1, + "ns/op": 54.29 + }, + "raw": "BenchmarkHandleSharedSnapshotPublishAndRead/read-18 \t20138788\t 54.29 ns/op\t 96 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 96, + "allocs/op": 1, + "ns/op": 54.29 + } + } + ] + }, + { + "lane": "native", + "package": "./interop", + "workspace": "./interop", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 5, + "benchmarks": [ + { + "name": "BenchmarkDecodeMapToStruct-18", + "bucket": "memory", + "samples": [ + { + "iterations": 470156, + "metrics": { + "B/op": 1137, + "allocs/op": 29, + "ns/op": 2762 + }, + "raw": "BenchmarkDecodeMapToStruct-18 \t 470156\t 2762 ns/op\t 1137 B/op\t 29 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1137, + "allocs/op": 29, + "ns/op": 2762 + } + }, + { + "name": "BenchmarkInteropErrorString-18", + "bucket": "compute", + "samples": [ + { + "iterations": 4476219, + "metrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 235.1 + }, + "raw": "BenchmarkInteropErrorString-18 \t 4476219\t 235.1 ns/op\t 480 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 480, + "allocs/op": 5, + "ns/op": 235.1 + } + }, + { + "name": "BenchmarkClientCanExchangeMicro-18", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 9400778, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 134.7 + }, + "raw": "BenchmarkClientCanExchangeMicro-18 \t 9400778\t 134.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 134.7 + } + }, + { + "name": "BenchmarkRequestWorkerDecodedFanoutDispatch/direct-lanes-18", + "bucket": "memory", + "samples": [ + { + "iterations": 70532, + "metrics": { + "B/op": 3380, + "allocs/op": 83, + "ns/op": 17374 + }, + "raw": "BenchmarkRequestWorkerDecodedFanoutDispatch/direct-lanes-18 \t 70532\t 17374 ns/op\t 3380 B/op\t 83 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3380, + "allocs/op": 83, + "ns/op": 17374 + } + }, + { + "name": "BenchmarkRequestWorkerDecodedFanoutDispatch/worker-pool-18", + "bucket": "memory", + "samples": [ + { + "iterations": 66861, + "metrics": { + "B/op": 3396, + "allocs/op": 83, + "ns/op": 19114 + }, + "raw": "BenchmarkRequestWorkerDecodedFanoutDispatch/worker-pool-18 \t 66861\t 19114 ns/op\t 3396 B/op\t 83 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3396, + "allocs/op": 83, + "ns/op": 19114 + } + } + ] + }, + { + "lane": "native", + "package": "./logging", + "workspace": "./logging", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkCloneFieldsSmall-18", + "bucket": "memory", + "samples": [ + { + "iterations": 9388584, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 131.7 + }, + "raw": "BenchmarkCloneFieldsSmall-18 \t 9388584\t 131.7 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 131.7 + } + }, + { + "name": "BenchmarkLoggerScope-18", + "bucket": "compute", + "samples": [ + { + "iterations": 536965606, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.237 + }, + "raw": "BenchmarkLoggerScope-18 \t536965606\t 2.237 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.237 + } + }, + { + "name": "BenchmarkCloneFieldsMicro-18", + "bucket": "memory", + "samples": [ + { + "iterations": 11152653, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 110.8 + }, + "raw": "BenchmarkCloneFieldsMicro-18 \t11152653\t 110.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 110.8 + } + } + ] + }, + { + "lane": "native", + "package": "./plugin", + "workspace": "./plugin", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkEvaluateRouteMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 64882830, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.18 + }, + "raw": "BenchmarkEvaluateRouteMicro-18 \t64882830\t 18.18 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.18 + } + }, + { + "name": "BenchmarkNewHostWithCapabilities-18", + "bucket": "compute", + "samples": [ + { + "iterations": 4370875, + "metrics": { + "B/op": 656, + "allocs/op": 4, + "ns/op": 271.6 + }, + "raw": "BenchmarkNewHostWithCapabilities-18 \t 4370875\t 271.6 ns/op\t 656 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 656, + "allocs/op": 4, + "ns/op": 271.6 + } + }, + { + "name": "BenchmarkEvaluateRouteWithSingleAllowGuard-18", + "bucket": "compute", + "samples": [ + { + "iterations": 66534705, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.25 + }, + "raw": "BenchmarkEvaluateRouteWithSingleAllowGuard-18 \t66534705\t 18.25 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 18.25 + } + } + ] + }, + { + "lane": "native", + "package": "./prerender", + "workspace": "./prerender", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkNormalizeRoutePath-18", + "bucket": "compute", + "samples": [ + { + "iterations": 139979986, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.702 + }, + "raw": "BenchmarkNormalizeRoutePath-18 \t139979986\t 8.702 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 8.702 + } + }, + { + "name": "BenchmarkBuildTargetJSONBootstrap-18", + "bucket": "memory", + "samples": [ + { + "iterations": 2162886, + "metrics": { + "B/op": 408, + "allocs/op": 12, + "ns/op": 556.6 + }, + "raw": "BenchmarkBuildTargetJSONBootstrap-18 \t 2162886\t 556.6 ns/op\t 408 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 408, + "allocs/op": 12, + "ns/op": 556.6 + } + }, + { + "name": "BenchmarkNormalizeRoutePathMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 163468585, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.439 + }, + "raw": "BenchmarkNormalizeRoutePathMicro-18 \t163468585\t 7.439 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.439 + } + } + ] + }, + { + "lane": "native", + "package": "./pwa", + "workspace": "./pwa", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkBuildServiceWorkerAssetPlanMicro-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 376267, + "metrics": { + "B/op": 2704, + "allocs/op": 25, + "ns/op": 3245 + }, + "raw": "BenchmarkBuildServiceWorkerAssetPlanMicro-18 \t 376267\t 3245 ns/op\t 2704 B/op\t 25 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2704, + "allocs/op": 25, + "ns/op": 3245 + } + }, + { + "name": "BenchmarkMarshalManifestJSON-18", + "bucket": "memory", + "samples": [ + { + "iterations": 1591868, + "metrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 750.6 + }, + "raw": "BenchmarkMarshalManifestJSON-18 \t 1591868\t 750.6 ns/op\t 496 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 496, + "allocs/op": 2, + "ns/op": 750.6 + } + }, + { + "name": "BenchmarkBuildServiceWorkerAssetPlan-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 352236, + "metrics": { + "B/op": 2848, + "allocs/op": 25, + "ns/op": 3742 + }, + "raw": "BenchmarkBuildServiceWorkerAssetPlan-18 \t 352236\t 3742 ns/op\t 2848 B/op\t 25 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2848, + "allocs/op": 25, + "ns/op": 3742 + } + } + ] + }, + { + "lane": "native", + "package": "./router", + "workspace": "./router", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkRouteContractMustHrefForMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 1354911, + "metrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 816.8 + }, + "raw": "BenchmarkRouteContractMustHrefForMicro-18 \t 1354911\t 816.8 ns/op\t 952 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 816.8 + } + } + ] + }, + { + "lane": "native", + "package": "./sanitize", + "workspace": "./sanitize", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkSanitizeLargeDocument-18", + "bucket": "compute", + "samples": [ + { + "iterations": 1011, + "metrics": { + "B/op": 679301, + "allocs/op": 7050, + "ns/op": 1239798 + }, + "raw": "BenchmarkSanitizeLargeDocument-18 \t 1011\t 1239798 ns/op\t 679301 B/op\t 7050 allocs/op" + } + ], + "averageMetrics": { + "B/op": 679301, + "allocs/op": 7050, + "ns/op": 1239798 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/hooks", + "workspace": "./testkit/hooks", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkHarnessStubMethodsMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2823 + }, + "raw": "BenchmarkHarnessStubMethodsMicro-18 \t1000000000\t 0.2823 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2823 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/render", + "workspace": "./testkit/render", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkNewResourceControllerMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 25486526, + "metrics": { + "B/op": 240, + "allocs/op": 1, + "ns/op": 54.9 + }, + "raw": "BenchmarkNewResourceControllerMicro-18 \t25486526\t 54.90 ns/op\t 240 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 240, + "allocs/op": 1, + "ns/op": 54.9 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/router", + "workspace": "./testkit/router", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkFixtureStubMethodsMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 1000000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2817 + }, + "raw": "BenchmarkFixtureStubMethodsMicro-18 \t1000000000\t 0.2817 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 0.2817 + } + } + ] + }, + { + "lane": "native", + "package": "./testkit/ssr", + "workspace": "./testkit/ssr", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 1, + "benchmarks": [ + { + "name": "BenchmarkNormalizeStaticRoutePathMicro-18", + "bucket": "compute", + "samples": [ + { + "iterations": 151090533, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.591 + }, + "raw": "BenchmarkNormalizeStaticRoutePathMicro-18 \t151090533\t 7.591 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 7.591 + } + } + ] + }, + { + "lane": "native", + "package": "./ui", + "workspace": "./ui", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 8, + "benchmarks": [ + { + "name": "BenchmarkRenderToStringMicro-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 11027982, + "metrics": { + "B/op": 64, + "allocs/op": 3, + "ns/op": 100.8 + }, + "raw": "BenchmarkRenderToStringMicro-18 \t11027982\t 100.8 ns/op\t 64 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 64, + "allocs/op": 3, + "ns/op": 100.8 + } + }, + { + "name": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-18", + "bucket": "memory", + "samples": [ + { + "iterations": 220194, + "metrics": { + "B/op": 5541, + "allocs/op": 81, + "ns/op": 5891 + }, + "raw": "BenchmarkMarshalUnmarshalSSRBootstrapMicro-18 \t 220194\t 5891 ns/op\t 5541 B/op\t 81 allocs/op" + } + ], + "averageMetrics": { + "B/op": 5541, + "allocs/op": 81, + "ns/op": 5891 + } + }, + { + "name": "BenchmarkRenderToStringPublicSSRSurface-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 526682, + "metrics": { + "B/op": 3504, + "allocs/op": 45, + "ns/op": 2835 + }, + "raw": "BenchmarkRenderToStringPublicSSRSurface-18 \t 526682\t 2835 ns/op\t 3504 B/op\t 45 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3504, + "allocs/op": 45, + "ns/op": 2835 + } + }, + { + "name": "BenchmarkMarshalSSRBootstrapJSON-18", + "bucket": "memory", + "samples": [ + { + "iterations": 365839, + "metrics": { + "B/op": 3483, + "allocs/op": 43, + "ns/op": 3046 + }, + "raw": "BenchmarkMarshalSSRBootstrapJSON-18 \t 365839\t 3046 ns/op\t 3483 B/op\t 43 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3483, + "allocs/op": 43, + "ns/op": 3046 + } + }, + { + "name": "BenchmarkMarshalSSRBootstrapBinary-18", + "bucket": "memory", + "samples": [ + { + "iterations": 970088, + "metrics": { + "B/op": 418, + "allocs/op": 4, + "ns/op": 1068 + }, + "raw": "BenchmarkMarshalSSRBootstrapBinary-18 \t 970088\t 1068 ns/op\t 418 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 418, + "allocs/op": 4, + "ns/op": 1068 + } + }, + { + "name": "BenchmarkUnmarshalSSRBootstrapJSON-18", + "bucket": "memory", + "samples": [ + { + "iterations": 402862, + "metrics": { + "B/op": 2328, + "allocs/op": 54, + "ns/op": 3468 + }, + "raw": "BenchmarkUnmarshalSSRBootstrapJSON-18 \t 402862\t 3468 ns/op\t 2328 B/op\t 54 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2328, + "allocs/op": 54, + "ns/op": 3468 + } + }, + { + "name": "BenchmarkUnmarshalSSRBootstrapBinary-18", + "bucket": "memory", + "samples": [ + { + "iterations": 619843, + "metrics": { + "B/op": 1976, + "allocs/op": 42, + "ns/op": 2602 + }, + "raw": "BenchmarkUnmarshalSSRBootstrapBinary-18 \t 619843\t 2602 ns/op\t 1976 B/op\t 42 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1976, + "allocs/op": 42, + "ns/op": 2602 + } + }, + { + "name": "BenchmarkRenderBootstrapReferenceScript-18", + "bucket": "memory", + "samples": [ + { + "iterations": 708572, + "metrics": { + "B/op": 1753, + "allocs/op": 19, + "ns/op": 1765 + }, + "raw": "BenchmarkRenderBootstrapReferenceScript-18 \t 708572\t 1765 ns/op\t 1753 B/op\t 19 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1753, + "allocs/op": 19, + "ns/op": 1765 + } + } + ] + }, + { + "lane": "native", + "package": "./virtualization", + "workspace": "./virtualization", + "command": "go test -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 3, + "benchmarks": [ + { + "name": "BenchmarkComputeViewportStateMicro-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 252259032, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.769 + }, + "raw": "BenchmarkComputeViewportStateMicro-18 \t252259032\t 4.769 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 4.769 + } + }, + { + "name": "BenchmarkComputeViewportState-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 177105720, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6.872 + }, + "raw": "BenchmarkComputeViewportState-18 \t177105720\t 6.872 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 6.872 + } + }, + { + "name": "BenchmarkViewportDiagnosticsWithRowLifecycle-18", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 100000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10.5 + }, + "raw": "BenchmarkViewportDiagnosticsWithRowLifecycle-18 \t100000000\t 10.50 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10.5 + } + } + ] + }, + { + "lane": "wasm", + "package": "./fetch", + "workspace": "./fetch", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 5, + "benchmarks": [ + { + "name": "BenchmarkResolveMutationQueueOptions", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 37441291, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 33.38 + }, + "raw": "BenchmarkResolveMutationQueueOptions \t37441291\t 33.38 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 33.38 + } + }, + { + "name": "BenchmarkNormalizeMutationID", + "bucket": "compute", + "samples": [ + { + "iterations": 2779288, + "metrics": { + "B/op": 40, + "allocs/op": 2, + "ns/op": 440.1 + }, + "raw": "BenchmarkNormalizeMutationID \t 2779288\t 440.1 ns/op\t 40 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 40, + "allocs/op": 2, + "ns/op": 440.1 + } + }, + { + "name": "BenchmarkMergeResolvedMutation", + "bucket": "compute", + "samples": [ + { + "iterations": 783298, + "metrics": { + "B/op": 696, + "allocs/op": 6, + "ns/op": 1415 + }, + "raw": "BenchmarkMergeResolvedMutation \t 783298\t 1415 ns/op\t 696 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 696, + "allocs/op": 6, + "ns/op": 1415 + } + }, + { + "name": "BenchmarkBuildMultipartFormData", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 9154, + "metrics": { + "B/op": 392, + "allocs/op": 35, + "ns/op": 111695 + }, + "raw": "BenchmarkBuildMultipartFormData \t 9154\t 111695 ns/op\t 392 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 392, + "allocs/op": 35, + "ns/op": 111695 + } + }, + { + "name": "BenchmarkNormalizeMutationIDMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 2594545, + "metrics": { + "B/op": 63, + "allocs/op": 2, + "ns/op": 472.4 + }, + "raw": "BenchmarkNormalizeMutationIDMicro \t 2594545\t 472.4 ns/op\t 63 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 63, + "allocs/op": 2, + "ns/op": 472.4 + } + } + ] + }, + { + "lane": "wasm", + "package": "./internal/platform/jsdom", + "workspace": "./internal/platform/jsdom", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": false, + "benchmarkCount": 0, + "error": "go test -exec C:\\Users\\mreca\\Desktop\\GoWebComponents\\tools\\go_js_wasm_exec.bat -run ^$ -bench . -benchmem -count 1 . failed: goos: js\ngoarch: wasm\npkg: github.com/monstercameron/GoWebComponents/internal/platform/jsdom\nBenchmarkWASMDOMAdapterCreateElement \t 17530\t 68786 ns/op\t 248 B/op\t 24 allocs/op\npanic: syscall/js: Value.Call: property setAttribute is not a function, got undefined\n\ngoroutine 20 [running]:\nsyscall/js.Value.Call({{}, 0x7ff8000100017e09, 0x4e9900}, {0x68205, 0xc}, {0x4c3ed8, 0x2, 0x2})\n\tC:/Program Files/Go/src/syscall/js/js.go:441 +0x21\ngithub.com/monstercameron/GoWebComponents/internal/platform/jsdom.(*WASMDOMAdapter).SetAttribute(...)\n\tC:/Users/mreca/Desktop/GoWebComponents/internal/platform/jsdom/adapters.go:276\ngithub.com/monstercameron/GoWebComponents/internal/platform/jsdom.BenchmarkWASMDOMAdapterSetAttribute(0x4b0608)\n\tC:/Users/mreca/Desktop/GoWebComponents/internal/platform/jsdom/adapters_benchmark_test.go:322 +0x1f\ntesting.(*B).runN(0x4b0608, 0x1)\n\tC:/Program Files/Go/src/testing/benchmark.go:219 +0x11\ntesting.(*B).run1.func1()\n\tC:/Program Files/Go/src/testing/benchmark.go:245 +0x2\ncreated by testing.(*B).run1 in goroutine 1\n\tC:/Program Files/Go/src/testing/benchmark.go:238 +0xa\nexit status 2\nFAIL\tgithub.com/monstercameron/GoWebComponents/internal/platform/jsdom\t2.141s\nFAIL", + "output": "goos: js\ngoarch: wasm\npkg: github.com/monstercameron/GoWebComponents/internal/platform/jsdom\nBenchmarkWASMDOMAdapterCreateElement \t 17530\t 68786 ns/op\t 248 B/op\t 24 allocs/op\npanic: syscall/js: Value.Call: property setAttribute is not a function, got undefined\n\ngoroutine 20 [running]:\nsyscall/js.Value.Call({{}, 0x7ff8000100017e09, 0x4e9900}, {0x68205, 0xc}, {0x4c3ed8, 0x2, 0x2})\n\tC:/Program Files/Go/src/syscall/js/js.go:441 +0x21\ngithub.com/monstercameron/GoWebComponents/internal/platform/jsdom.(*WASMDOMAdapter).SetAttribute(...)\n\tC:/Users/mreca/Desktop/GoWebComponents/internal/platform/jsdom/adapters.go:276\ngithub.com/monstercameron/GoWebComponents/internal/platform/jsdom.BenchmarkWASMDOMAdapterSetAttribute(0x4b0608)\n\tC:/Users/mreca/Desktop/GoWebComponents/internal/platform/jsdom/adapters_benchmark_test.go:322 +0x1f\ntesting.(*B).runN(0x4b0608, 0x1)\n\tC:/Program Files/Go/src/testing/benchmark.go:219 +0x11\ntesting.(*B).run1.func1()\n\tC:/Program Files/Go/src/testing/benchmark.go:245 +0x2\ncreated by testing.(*B).run1 in goroutine 1\n\tC:/Program Files/Go/src/testing/benchmark.go:238 +0xa\nexit status 2\nFAIL\tgithub.com/monstercameron/GoWebComponents/internal/platform/jsdom\t2.141s\nFAIL" + }, + { + "lane": "wasm", + "package": "./internal/runtime", + "workspace": "./internal/runtime", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 94, + "benchmarks": [ + { + "name": "BenchmarkGoEventGetValue", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 185814, + "metrics": { + "B/op": 24, + "allocs/op": 3, + "ns/op": 6191 + }, + "raw": "BenchmarkGoEventGetValue \t 185814\t 6191 ns/op\t 24 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 3, + "ns/op": 6191 + } + }, + { + "name": "BenchmarkGoEventIsChecked", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 343446, + "metrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 3623 + }, + "raw": "BenchmarkGoEventIsChecked \t 343446\t 3623 ns/op\t 8 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 8, + "allocs/op": 1, + "ns/op": 3623 + } + }, + { + "name": "BenchmarkGoEventGetKey", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 399217, + "metrics": { + "B/op": 16, + "allocs/op": 2, + "ns/op": 3284 + }, + "raw": "BenchmarkGoEventGetKey \t 399217\t 3284 ns/op\t 16 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 16, + "allocs/op": 2, + "ns/op": 3284 + } + }, + { + "name": "BenchmarkGoEventGetKeyCode", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 2162758, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 558.4 + }, + "raw": "BenchmarkGoEventGetKeyCode \t 2162758\t 558.4 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 558.4 + } + }, + { + "name": "BenchmarkGoEventGetTarget", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 413745, + "metrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 3109 + }, + "raw": "BenchmarkGoEventGetTarget \t 413745\t 3109 ns/op\t 24 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 2, + "ns/op": 3109 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 10000, + "metrics": { + "B/op": 10097, + "allocs/op": 149, + "ns/op": 124313 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardComponentUpdate16 \t 10000\t 124313 ns/op\t 10097 B/op\t 149 allocs/op" + } + ], + "averageMetrics": { + "B/op": 10097, + "allocs/op": 149, + "ns/op": 124313 + } + }, + { + "name": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 52988, + "metrics": { + "B/op": 185, + "allocs/op": 7, + "ns/op": 48765 + }, + "raw": "BenchmarkFineGrainedKeyedDashboardReactiveTextUpdate16 \t 52988\t 48765 ns/op\t 185 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 185, + "allocs/op": 7, + "ns/op": 48765 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6978, + "metrics": { + "B/op": 9992, + "allocs/op": 134, + "ns/op": 198306 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardComponentUpdate16 \t 6978\t 198306 ns/op\t 9992 B/op\t 134 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9992, + "allocs/op": 134, + "ns/op": 198306 + } + }, + { + "name": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 41956, + "metrics": { + "B/op": 241, + "allocs/op": 10, + "ns/op": 69673 + }, + "raw": "BenchmarkFineGrainedSelectorDashboardReactiveTextUpdate16 \t 41956\t 69673 ns/op\t 241 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 241, + "allocs/op": 10, + "ns/op": 69673 + } + }, + { + "name": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 16501, + "metrics": { + "B/op": 760, + "allocs/op": 16, + "ns/op": 78436 + }, + "raw": "BenchmarkFineGrainedSignalStyleDashboardReactiveRegions16 \t 16501\t 78436 ns/op\t 760 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 760, + "allocs/op": 16, + "ns/op": 78436 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5073, + "metrics": { + "B/op": 3080, + "allocs/op": 33, + "ns/op": 312580 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderStaticLeaves64 \t 5073\t 312580 ns/op\t 3080 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3080, + "allocs/op": 33, + "ns/op": 312580 + } + }, + { + "name": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4839, + "metrics": { + "B/op": 3080, + "allocs/op": 33, + "ns/op": 330298 + }, + "raw": "BenchmarkFineGrainedAncestorRerenderReactiveRegions64 \t 4839\t 330298 ns/op\t 3080 B/op\t 33 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3080, + "allocs/op": 33, + "ns/op": 330298 + } + }, + { + "name": "BenchmarkIsNilableTypeCachedPointer", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 7282129, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 163.2 + }, + "raw": "BenchmarkIsNilableTypeCachedPointer \t 7282129\t 163.2 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 163.2 + } + }, + { + "name": "BenchmarkFastEqualInt", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 70605057, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.97 + }, + "raw": "BenchmarkFastEqualInt \t70605057\t 16.97 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16.97 + } + }, + { + "name": "BenchmarkFastEqualString", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 39755234, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 27 + }, + "raw": "BenchmarkFastEqualString \t39755234\t 27.00 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 27 + } + }, + { + "name": "BenchmarkAreDepsEqual3Primitives", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 17296154, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 71.14 + }, + "raw": "BenchmarkAreDepsEqual3Primitives \t17296154\t 71.14 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 71.14 + } + }, + { + "name": "BenchmarkGoUseStateIntDirectUpdate", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 771337, + "metrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 1981 + }, + "raw": "BenchmarkGoUseStateIntDirectUpdate \t 771337\t 1981 ns/op\t 599 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 1981 + } + }, + { + "name": "BenchmarkGoUseStatePointerNilReset", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 693194, + "metrics": { + "B/op": 564, + "allocs/op": 3, + "ns/op": 1683 + }, + "raw": "BenchmarkGoUseStatePointerNilReset \t 693194\t 1683 ns/op\t 564 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 564, + "allocs/op": 3, + "ns/op": 1683 + } + }, + { + "name": "BenchmarkGoUseMemoSameDeps", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 47757, + "metrics": { + "B/op": 234, + "allocs/op": 3, + "ns/op": 25251 + }, + "raw": "BenchmarkGoUseMemoSameDeps \t 47757\t 25251 ns/op\t 234 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 234, + "allocs/op": 3, + "ns/op": 25251 + } + }, + { + "name": "BenchmarkGoUseCallbackSameDeps", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 66356, + "metrics": { + "B/op": 227, + "allocs/op": 3, + "ns/op": 18768 + }, + "raw": "BenchmarkGoUseCallbackSameDeps \t 66356\t 18768 ns/op\t 227 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 227, + "allocs/op": 3, + "ns/op": 18768 + } + }, + { + "name": "BenchmarkGoUseRefStable", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 71108, + "metrics": { + "B/op": 205, + "allocs/op": 2, + "ns/op": 17366 + }, + "raw": "BenchmarkGoUseRefStable \t 71108\t 17366 ns/op\t 205 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 205, + "allocs/op": 2, + "ns/op": 17366 + } + }, + { + "name": "BenchmarkGoUseIdStable", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 62334, + "metrics": { + "B/op": 216, + "allocs/op": 2, + "ns/op": 19881 + }, + "raw": "BenchmarkGoUseIdStable \t 62334\t 19881 ns/op\t 216 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 216, + "allocs/op": 2, + "ns/op": 19881 + } + }, + { + "name": "BenchmarkGoUseFuncWrap", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 58552, + "metrics": { + "B/op": 202, + "allocs/op": 2, + "ns/op": 21311 + }, + "raw": "BenchmarkGoUseFuncWrap \t 58552\t 21311 ns/op\t 202 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 202, + "allocs/op": 2, + "ns/op": 21311 + } + }, + { + "name": "BenchmarkGoUseEffectSameDeps", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 67492, + "metrics": { + "B/op": 226, + "allocs/op": 3, + "ns/op": 18058 + }, + "raw": "BenchmarkGoUseEffectSameDeps \t 67492\t 18058 ns/op\t 226 B/op\t 3 allocs/op" + } + ], + "averageMetrics": { + "B/op": 226, + "allocs/op": 3, + "ns/op": 18058 + } + }, + { + "name": "BenchmarkGoUseFetchInit", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 62845, + "metrics": { + "B/op": 824, + "allocs/op": 7, + "ns/op": 19515 + }, + "raw": "BenchmarkGoUseFetchInit \t 62845\t 19515 ns/op\t 824 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 824, + "allocs/op": 7, + "ns/op": 19515 + } + }, + { + "name": "BenchmarkGoUseFetchRefetchUnavailable", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 100, + "metrics": { + "B/op": 210, + "allocs/op": 5, + "ns/op": 13077176 + }, + "raw": "BenchmarkGoUseFetchRefetchUnavailable \t 100\t 13077176 ns/op\t 210 B/op\t 5 allocs/op" + } + ], + "averageMetrics": { + "B/op": 210, + "allocs/op": 5, + "ns/op": 13077176 + } + }, + { + "name": "BenchmarkFormatHookIDCurrentVsLegacy/legacy", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1769227, + "metrics": { + "B/op": 13, + "allocs/op": 1, + "ns/op": 667.9 + }, + "raw": "BenchmarkFormatHookIDCurrentVsLegacy/legacy \t 1769227\t 667.9 ns/op\t 13 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 13, + "allocs/op": 1, + "ns/op": 667.9 + } + }, + { + "name": "BenchmarkFormatHookIDCurrentVsLegacy/current", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5802136, + "metrics": { + "B/op": 10, + "allocs/op": 1, + "ns/op": 210.2 + }, + "raw": "BenchmarkFormatHookIDCurrentVsLegacy/current \t 5802136\t 210.2 ns/op\t 10 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 10, + "allocs/op": 1, + "ns/op": 210.2 + } + }, + { + "name": "BenchmarkDivWithTextChildren", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 540009, + "metrics": { + "B/op": 872, + "allocs/op": 7, + "ns/op": 2557 + }, + "raw": "BenchmarkDivWithTextChildren \t 540009\t 2557 ns/op\t 872 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 872, + "allocs/op": 7, + "ns/op": 2557 + } + }, + { + "name": "BenchmarkDivWithComponents4", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 469920, + "metrics": { + "B/op": 1016, + "allocs/op": 10, + "ns/op": 2648 + }, + "raw": "BenchmarkDivWithComponents4 \t 469920\t 2648 ns/op\t 1016 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1016, + "allocs/op": 10, + "ns/op": 2648 + } + }, + { + "name": "BenchmarkWithComponentsGeneric4", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 444890, + "metrics": { + "B/op": 1032, + "allocs/op": 11, + "ns/op": 2719 + }, + "raw": "BenchmarkWithComponentsGeneric4 \t 444890\t 2719 ns/op\t 1032 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1032, + "allocs/op": 11, + "ns/op": 2719 + } + }, + { + "name": "BenchmarkHydrateSimpleReuse", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 23557, + "metrics": { + "B/op": 9032, + "allocs/op": 75, + "ns/op": 50596 + }, + "raw": "BenchmarkHydrateSimpleReuse \t 23557\t 50596 ns/op\t 9032 B/op\t 75 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9032, + "allocs/op": 75, + "ns/op": 50596 + } + }, + { + "name": "BenchmarkHydrateTagMismatchFallback", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 23980, + "metrics": { + "B/op": 9152, + "allocs/op": 78, + "ns/op": 50491 + }, + "raw": "BenchmarkHydrateTagMismatchFallback \t 23980\t 50491 ns/op\t 9152 B/op\t 78 allocs/op" + } + ], + "averageMetrics": { + "B/op": 9152, + "allocs/op": 78, + "ns/op": 50491 + } + }, + { + "name": "BenchmarkHydrateMediumTreeReuse", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 319, + "metrics": { + "B/op": 466857, + "allocs/op": 7107, + "ns/op": 3676051 + }, + "raw": "BenchmarkHydrateMediumTreeReuse \t 319\t 3676051 ns/op\t 466857 B/op\t 7107 allocs/op" + } + ], + "averageMetrics": { + "B/op": 466857, + "allocs/op": 7107, + "ns/op": 3676051 + } + }, + { + "name": "BenchmarkHydrateMediumTreeFirstUpdate", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 312, + "metrics": { + "B/op": 447243, + "allocs/op": 6374, + "ns/op": 3812901 + }, + "raw": "BenchmarkHydrateMediumTreeFirstUpdate \t 312\t 3812901 ns/op\t 447243 B/op\t 6374 allocs/op" + } + ], + "averageMetrics": { + "B/op": 447243, + "allocs/op": 6374, + "ns/op": 3812901 + } + }, + { + "name": "BenchmarkDOMNodeInterfaceEquals", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 104743864, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.53 + }, + "raw": "BenchmarkDOMNodeInterfaceEquals \t104743864\t 11.53 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.53 + } + }, + { + "name": "BenchmarkDOMAdapterInterfaceCreateElement", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 14743114, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 82.7 + }, + "raw": "BenchmarkDOMAdapterInterfaceCreateElement \t14743114\t 82.70 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 82.7 + } + }, + { + "name": "BenchmarkSchedulerInterfaceSetTimeout", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 5600485, + "metrics": { + "B/op": 48, + "allocs/op": 0, + "ns/op": 468.7 + }, + "raw": "BenchmarkSchedulerInterfaceSetTimeout \t 5600485\t 468.7 ns/op\t 48 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 0, + "ns/op": 468.7 + } + }, + { + "name": "BenchmarkRuntimeLayoutBaselines", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 859850353, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 104, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 400, + "hooks-align": 8, + "hooks-bytes": 472, + "ns/op": 1.396 + }, + "raw": "BenchmarkRuntimeLayoutBaselines \t859850353\t 1.396 ns/op\t 104.0 element-bytes\t 40.00 fetchstate-bytes\t 8.000 fiber-align\t 400.0 fiber-bytes\t 8.000 hooks-align\t 472.0 hooks-bytes\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "element-bytes": 104, + "fetchstate-bytes": 40, + "fiber-align": 8, + "fiber-bytes": 400, + "hooks-align": 8, + "hooks-bytes": 472, + "ns/op": 1.396 + } + }, + { + "name": "BenchmarkFiberHotFieldScan256", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1240249, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 958.3 + }, + "raw": "BenchmarkFiberHotFieldScan256 \t 1240249\t 958.3 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 958.3 + } + }, + { + "name": "BenchmarkFiberSiblingWalk256", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1218 + }, + "raw": "BenchmarkFiberSiblingWalk256 \t 1000000\t 1218 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1218 + } + }, + { + "name": "BenchmarkHooksIndexResetHotPath", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 58568126, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 20.62 + }, + "raw": "BenchmarkHooksIndexResetHotPath \t58568126\t 20.62 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 20.62 + } + }, + { + "name": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/current", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 21020461, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 54.33 + }, + "raw": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/current \t21020461\t 54.33 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 54.33 + } + }, + { + "name": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/legacy", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 117745, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10097 + }, + "raw": "BenchmarkHasCommittedPlacementChildrenAtLeastCurrentVsLegacy/legacy \t 117745\t 10097 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10097 + } + }, + { + "name": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/current", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1470, + "metrics": { + "B/op": 6720, + "allocs/op": 7, + "ns/op": 816010 + }, + "raw": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/current \t 1470\t 816010 ns/op\t 6720 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 6720, + "allocs/op": 7, + "ns/op": 816010 + } + }, + { + "name": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/legacy", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 34, + "metrics": { + "B/op": 1266928, + "allocs/op": 1657, + "ns/op": 36351134 + }, + "raw": "BenchmarkApplyCommittedChildOrderCurrentVsLegacy/legacy \t 34\t 36351134 ns/op\t 1266928 B/op\t 1657 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1266928, + "allocs/op": 1657, + "ns/op": 36351134 + } + }, + { + "name": "BenchmarkRenderPortalToSelector", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 25560, + "metrics": { + "B/op": 7631, + "allocs/op": 53, + "ns/op": 48865 + }, + "raw": "BenchmarkRenderPortalToSelector \t 25560\t 48865 ns/op\t 7631 B/op\t 53 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7631, + "allocs/op": 53, + "ns/op": 48865 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/large-list", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1136, + "metrics": { + "B/op": 348115, + "allocs/op": 1366, + "ns/op": 982961 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/large-list \t 1136\t 982961 ns/op\t 348115 B/op\t 1366 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348115, + "allocs/op": 1366, + "ns/op": 982961 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/nested-routes", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1285, + "metrics": { + "B/op": 348114, + "allocs/op": 1366, + "ns/op": 985357 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/nested-routes \t 1285\t 985357 ns/op\t 348114 B/op\t 1366 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348114, + "allocs/op": 1366, + "ns/op": 985357 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/async-dashboard", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1264, + "metrics": { + "B/op": 348114, + "allocs/op": 1366, + "ns/op": 965671 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/async-dashboard \t 1264\t 965671 ns/op\t 348114 B/op\t 1366 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348114, + "allocs/op": 1366, + "ns/op": 965671 + } + }, + { + "name": "BenchmarkProfilingRepresentativeScenarios/portal-overlays", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 1261, + "metrics": { + "B/op": 348114, + "allocs/op": 1366, + "ns/op": 1016439 + }, + "raw": "BenchmarkProfilingRepresentativeScenarios/portal-overlays \t 1261\t 1016439 ns/op\t 348114 B/op\t 1366 allocs/op" + } + ], + "averageMetrics": { + "B/op": 348114, + "allocs/op": 1366, + "ns/op": 1016439 + } + }, + { + "name": "BenchmarkCreateElementHostWithTextChildren", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 368010, + "metrics": { + "B/op": 936, + "allocs/op": 7, + "ns/op": 3493 + }, + "raw": "BenchmarkCreateElementHostWithTextChildren \t 368010\t 3493 ns/op\t 936 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 936, + "allocs/op": 7, + "ns/op": 3493 + } + }, + { + "name": "BenchmarkCreateElementHostWithDirectTextChild", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 453142, + "metrics": { + "B/op": 584, + "allocs/op": 6, + "ns/op": 2835 + }, + "raw": "BenchmarkCreateElementHostWithDirectTextChild \t 453142\t 2835 ns/op\t 584 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 584, + "allocs/op": 6, + "ns/op": 2835 + } + }, + { + "name": "BenchmarkPropsEqualChildrenSamePointer", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 3590528, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 339 + }, + "raw": "BenchmarkPropsEqualChildrenSamePointer \t 3590528\t 339.0 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 339 + } + }, + { + "name": "BenchmarkPropsEqualChildrenDifferentPointer", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 4144573, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 287.9 + }, + "raw": "BenchmarkPropsEqualChildrenDifferentPointer \t 4144573\t 287.9 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 287.9 + } + }, + { + "name": "BenchmarkReconcileChildrenStableList16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 80142, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15134 + }, + "raw": "BenchmarkReconcileChildrenStableList16 \t 80142\t 15134 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 15134 + } + }, + { + "name": "BenchmarkReconcileChildrenWithFragments16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 78556, + "metrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 15299 + }, + "raw": "BenchmarkReconcileChildrenWithFragments16 \t 78556\t 15299 ns/op\t 24 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 24, + "allocs/op": 1, + "ns/op": 15299 + } + }, + { + "name": "BenchmarkReconcileChildrenKeyedStableList16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 65294, + "metrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 25815 + }, + "raw": "BenchmarkReconcileChildrenKeyedStableList16 \t 65294\t 25815 ns/op\t 48 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 25815 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 30463, + "metrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 40084 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentLeaf \t 30463\t 40084 ns/op\t 776 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 40084 + } + }, + { + "name": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 30586, + "metrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 40059 + }, + "raw": "BenchmarkPerformUnitOfWorkFunctionComponentNoPropsLeaf \t 30586\t 40059 ns/op\t 776 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 776, + "allocs/op": 6, + "ns/op": 40059 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesInitialRender", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 325075, + "metrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 3737 + }, + "raw": "BenchmarkUpdateDomPropertiesInitialRender \t 325075\t 3737 ns/op\t 1120 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1120, + "allocs/op": 7, + "ns/op": 3737 + } + }, + { + "name": "BenchmarkUpdateDomPropertiesSteadyState", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 385104, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3047 + }, + "raw": "BenchmarkUpdateDomPropertiesSteadyState \t 385104\t 3047 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 3047 + } + }, + { + "name": "BenchmarkCommitDeletionDomlessSubtree32", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 19623, + "metrics": { + "B/op": 23184, + "allocs/op": 171, + "ns/op": 61962 + }, + "raw": "BenchmarkCommitDeletionDomlessSubtree32 \t 19623\t 61962 ns/op\t 23184 B/op\t 171 allocs/op" + } + ], + "averageMetrics": { + "B/op": 23184, + "allocs/op": 171, + "ns/op": 61962 + } + }, + { + "name": "BenchmarkCommitWorkPlacementChain16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 64518, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16814 + }, + "raw": "BenchmarkCommitWorkPlacementChain16 \t 64518\t 16814 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 16814 + } + }, + { + "name": "BenchmarkRunEffectsChain16", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 83001, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14310 + }, + "raw": "BenchmarkRunEffectsChain16 \t 83001\t 14310 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 14310 + } + }, + { + "name": "BenchmarkGetGlobalRuntimeLazy", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 651457, + "metrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 2072 + }, + "raw": "BenchmarkGetGlobalRuntimeLazy \t 651457\t 2072 ns/op\t 1536 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 2072 + } + }, + { + "name": "BenchmarkInitGlobalRuntimeAfterLazyGet", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 566574, + "metrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 2344 + }, + "raw": "BenchmarkInitGlobalRuntimeAfterLazyGet \t 566574\t 2344 ns/op\t 1536 B/op\t 6 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 6, + "ns/op": 2344 + } + }, + { + "name": "BenchmarkRenderTo", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 101173, + "metrics": { + "B/op": 3400, + "allocs/op": 20, + "ns/op": 12064 + }, + "raw": "BenchmarkRenderTo \t 101173\t 12064 ns/op\t 3400 B/op\t 20 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3400, + "allocs/op": 20, + "ns/op": 12064 + } + }, + { + "name": "BenchmarkScheduleUpdate", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1398976, + "metrics": { + "B/op": 416, + "allocs/op": 1, + "ns/op": 822 + }, + "raw": "BenchmarkScheduleUpdate \t 1398976\t 822.0 ns/op\t 416 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 416, + "allocs/op": 1, + "ns/op": 822 + } + }, + { + "name": "BenchmarkScheduleUpdateSteadyState", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 9491460, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 128.4 + }, + "raw": "BenchmarkScheduleUpdateSteadyState \t 9491460\t 128.4 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 128.4 + } + }, + { + "name": "BenchmarkScheduleUpdateForFiberDepth32", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 482461, + "metrics": { + "B/op": 864, + "allocs/op": 4, + "ns/op": 2447 + }, + "raw": "BenchmarkScheduleUpdateForFiberDepth32 \t 482461\t 2447 ns/op\t 864 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 864, + "allocs/op": 4, + "ns/op": 2447 + } + }, + { + "name": "BenchmarkRender", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 29091, + "metrics": { + "B/op": 1490, + "allocs/op": 10, + "ns/op": 43573 + }, + "raw": "BenchmarkRender \t 29091\t 43573 ns/op\t 1490 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1490, + "allocs/op": 10, + "ns/op": 43573 + } + }, + { + "name": "BenchmarkRenderSteadyState", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 32161, + "metrics": { + "B/op": 1490, + "allocs/op": 10, + "ns/op": 42074 + }, + "raw": "BenchmarkRenderSteadyState \t 32161\t 42074 ns/op\t 1490 B/op\t 10 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1490, + "allocs/op": 10, + "ns/op": 42074 + } + }, + { + "name": "BenchmarkEnqueueUI", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 5877661, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 204.4 + }, + "raw": "BenchmarkEnqueueUI \t 5877661\t 204.4 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 204.4 + } + }, + { + "name": "BenchmarkProcessUIQueueBatch64", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 98107, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10951 + }, + "raw": "BenchmarkProcessUIQueueBatch64 \t 98107\t 10951 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10951 + } + }, + { + "name": "BenchmarkTransitionListRefresh250", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 786, + "metrics": { + "B/op": 144937, + "allocs/op": 1791, + "ns/op": 1629337 + }, + "raw": "BenchmarkTransitionListRefresh250 \t 786\t 1629337 ns/op\t 144937 B/op\t 1791 allocs/op" + } + ], + "averageMetrics": { + "B/op": 144937, + "allocs/op": 1791, + "ns/op": 1629337 + } + }, + { + "name": "BenchmarkTextShim", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 714556837, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.679 + }, + "raw": "BenchmarkTextShim \t714556837\t 1.679 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.679 + } + }, + { + "name": "BenchmarkGoUseStateGlobalInit", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 31434, + "metrics": { + "B/op": 1376, + "allocs/op": 11, + "ns/op": 38959 + }, + "raw": "BenchmarkGoUseStateGlobalInit \t 31434\t 38959 ns/op\t 1376 B/op\t 11 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1376, + "allocs/op": 11, + "ns/op": 38959 + } + }, + { + "name": "BenchmarkGoUseAtomGlobalInit", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 29108, + "metrics": { + "B/op": 1515, + "allocs/op": 13, + "ns/op": 41669 + }, + "raw": "BenchmarkGoUseAtomGlobalInit \t 29108\t 41669 ns/op\t 1515 B/op\t 13 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1515, + "allocs/op": 13, + "ns/op": 41669 + } + }, + { + "name": "BenchmarkSSRRenderToString100Rows", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 872, + "metrics": { + "B/op": 220909, + "allocs/op": 2506, + "ns/op": 1383636 + }, + "raw": "BenchmarkSSRRenderToString100Rows \t 872\t 1383636 ns/op\t 220909 B/op\t 2506 allocs/op" + } + ], + "averageMetrics": { + "B/op": 220909, + "allocs/op": 2506, + "ns/op": 1383636 + } + }, + { + "name": "BenchmarkAtomRegistryInitAtomExisting", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 6362886, + "metrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 192.2 + }, + "raw": "BenchmarkAtomRegistryInitAtomExisting \t 6362886\t 192.2 ns/op\t 7 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 7, + "allocs/op": 0, + "ns/op": 192.2 + } + }, + { + "name": "BenchmarkAtomRegistryGetAtom", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 13889094, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 88.2 + }, + "raw": "BenchmarkAtomRegistryGetAtom \t13889094\t 88.20 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 88.2 + } + }, + { + "name": "BenchmarkAtomRegistrySubscribeUnsubscribe", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 1000000, + "metrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 1179 + }, + "raw": "BenchmarkAtomRegistrySubscribeUnsubscribe \t 1000000\t 1179 ns/op\t 192 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 192, + "allocs/op": 2, + "ns/op": 1179 + } + }, + { + "name": "BenchmarkAtomRegistrySetAtom32Subscribers", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 425845, + "metrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 4399 + }, + "raw": "BenchmarkAtomRegistrySetAtom32Subscribers \t 425845\t 4399 ns/op\t 264 B/op\t 1 allocs/op" + } + ], + "averageMetrics": { + "B/op": 264, + "allocs/op": 1, + "ns/op": 4399 + } + }, + { + "name": "BenchmarkGoUseAtomIntUpdate", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 451050, + "metrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 2643 + }, + "raw": "BenchmarkGoUseAtomIntUpdate \t 451050\t 2643 ns/op\t 599 B/op\t 7 allocs/op" + } + ], + "averageMetrics": { + "B/op": 599, + "allocs/op": 7, + "ns/op": 2643 + } + }, + { + "name": "BenchmarkGoUseAtomPointerNilReset", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 494409, + "metrics": { + "B/op": 572, + "allocs/op": 4, + "ns/op": 2645 + }, + "raw": "BenchmarkGoUseAtomPointerNilReset \t 494409\t 2645 ns/op\t 572 B/op\t 4 allocs/op" + } + ], + "averageMetrics": { + "B/op": 572, + "allocs/op": 4, + "ns/op": 2645 + } + }, + { + "name": "BenchmarkGoUseAtomGetter", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 12570730, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 102.8 + }, + "raw": "BenchmarkGoUseAtomGetter \t12570730\t 102.8 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 102.8 + } + }, + { + "name": "BenchmarkGoUseAtomStableRerender", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 59197, + "metrics": { + "B/op": 201, + "allocs/op": 2, + "ns/op": 19049 + }, + "raw": "BenchmarkGoUseAtomStableRerender \t 59197\t 19049 ns/op\t 201 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 201, + "allocs/op": 2, + "ns/op": 19049 + } + }, + { + "name": "BenchmarkCleanupAtomSubscriptions8", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 102676, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 9810 + }, + "raw": "BenchmarkCleanupAtomSubscriptions8 \t 102676\t 9810 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 9810 + } + }, + { + "name": "BenchmarkAtomRegistryUnsubscribeMany8", + "bucket": "sync_concurrency", + "samples": [ + { + "iterations": 129302, + "metrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 9473 + }, + "raw": "BenchmarkAtomRegistryUnsubscribeMany8 \t 129302\t 9473 ns/op\t 1536 B/op\t 16 allocs/op" + } + ], + "averageMetrics": { + "B/op": 1536, + "allocs/op": 16, + "ns/op": 9473 + } + }, + { + "name": "BenchmarkFiberAllocation", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 13231657, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 90.78 + }, + "raw": "BenchmarkFiberAllocation \t13231657\t 90.78 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 90.78 + } + }, + { + "name": "BenchmarkElementLiteralCreation", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 714393484, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.708 + }, + "raw": "BenchmarkElementLiteralCreation \t714393484\t 1.708 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.708 + } + }, + { + "name": "BenchmarkHooksPackedStateRead", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 713632162, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.678 + }, + "raw": "BenchmarkHooksPackedStateRead \t713632162\t 1.678 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1.678 + } + }, + { + "name": "BenchmarkFetchStateCopy", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 629115252, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.045 + }, + "raw": "BenchmarkFetchStateCopy \t629115252\t 2.045 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 2.045 + } + } + ] + }, + { + "lane": "wasm", + "package": "./interop", + "workspace": "./interop", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": false, + "benchmarkCount": 0, + "error": "go test -exec C:\\Users\\mreca\\Desktop\\GoWebComponents\\tools\\go_js_wasm_exec.bat -run ^$ -bench . -benchmem -count 1 . failed: --- FAIL: TestGetCookieNativeReturnsUnavailable (0.00s)\npanic: syscall/js: call of Value.Get on undefined [recovered, repanicked]\n\ngoroutine 18 [running]:\ntesting.tRunner.func1.2({0x3be00, 0x48c2d0})\n\tC:/Program Files/Go/src/testing/testing.go:1974 +0x20\ntesting.tRunner.func1()\n\tC:/Program Files/Go/src/testing/testing.go:1977 +0x37\npanic({0x3be00, 0x48c2d0})\n\tC:/Program Files/Go/src/runtime/panic.go:860 +0x1c\nsyscall/js.Value.Get({{}, 0x0, 0x0}, {0x808ac, 0x6})\n\tC:/Program Files/Go/src/syscall/js/js.go:296 +0xa\ngithub.com/monstercameron/GoWebComponents/interop.readRawCookies()\n\tC:/Users/mreca/Desktop/GoWebComponents/interop/cookie_wasm.go:9 +0x3\ngithub.com/monstercameron/GoWebComponents/interop.GetCookie({0x81423, 0x8})\n\tC:/Users/mreca/Desktop/GoWebComponents/interop/cookie.go:35 +0x2\ngithub.com/monstercameron/GoWebComponents/interop.TestGetCookieNativeReturnsUnavailable(0x58f8c8)\n\tC:/Users/mreca/Desktop/GoWebComponents/interop/cookie_test.go:126 +0x2\ntesting.tRunner(0x58f8c8, 0x9dad8)\n\tC:/Program Files/Go/src/testing/testing.go:2036 +0x12\ncreated by testing.(*T).Run in goroutine 1\n\tC:/Program Files/Go/src/testing/testing.go:2101 +0x54\nexit status 2\nFAIL\tgithub.com/monstercameron/GoWebComponents/interop\t0.232s\nFAIL", + "output": "--- FAIL: TestGetCookieNativeReturnsUnavailable (0.00s)\npanic: syscall/js: call of Value.Get on undefined [recovered, repanicked]\n\ngoroutine 18 [running]:\ntesting.tRunner.func1.2({0x3be00, 0x48c2d0})\n\tC:/Program Files/Go/src/testing/testing.go:1974 +0x20\ntesting.tRunner.func1()\n\tC:/Program Files/Go/src/testing/testing.go:1977 +0x37\npanic({0x3be00, 0x48c2d0})\n\tC:/Program Files/Go/src/runtime/panic.go:860 +0x1c\nsyscall/js.Value.Get({{}, 0x0, 0x0}, {0x808ac, 0x6})\n\tC:/Program Files/Go/src/syscall/js/js.go:296 +0xa\ngithub.com/monstercameron/GoWebComponents/interop.readRawCookies()\n\tC:/Users/mreca/Desktop/GoWebComponents/interop/cookie_wasm.go:9 +0x3\ngithub.com/monstercameron/GoWebComponents/interop.GetCookie({0x81423, 0x8})\n\tC:/Users/mreca/Desktop/GoWebComponents/interop/cookie.go:35 +0x2\ngithub.com/monstercameron/GoWebComponents/interop.TestGetCookieNativeReturnsUnavailable(0x58f8c8)\n\tC:/Users/mreca/Desktop/GoWebComponents/interop/cookie_test.go:126 +0x2\ntesting.tRunner(0x58f8c8, 0x9dad8)\n\tC:/Program Files/Go/src/testing/testing.go:2036 +0x12\ncreated by testing.(*T).Run in goroutine 1\n\tC:/Program Files/Go/src/testing/testing.go:2101 +0x54\nexit status 2\nFAIL\tgithub.com/monstercameron/GoWebComponents/interop\t0.232s\nFAIL" + }, + { + "lane": "wasm", + "package": "./router", + "workspace": "./router", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 4, + "benchmarks": [ + { + "name": "BenchmarkRouteContractMustHrefForMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 265894, + "metrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 4161 + }, + "raw": "BenchmarkRouteContractMustHrefForMicro \t 265894\t 4161 ns/op\t 952 B/op\t 12 allocs/op" + } + ], + "averageMetrics": { + "B/op": 952, + "allocs/op": 12, + "ns/op": 4161 + } + }, + { + "name": "BenchmarkResolveRouteStackNestedLayout", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 207248, + "metrics": { + "B/op": 2320, + "allocs/op": 15, + "ns/op": 5550 + }, + "raw": "BenchmarkResolveRouteStackNestedLayout \t 207248\t 5550 ns/op\t 2320 B/op\t 15 allocs/op" + } + ], + "averageMetrics": { + "B/op": 2320, + "allocs/op": 15, + "ns/op": 5550 + } + }, + { + "name": "BenchmarkCurrentNestedLayoutRoute", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 542, + "metrics": { + "B/op": 12954, + "allocs/op": 687, + "ns/op": 2242283 + }, + "raw": "BenchmarkCurrentNestedLayoutRoute \t 542\t 2242283 ns/op\t 12954 B/op\t 687 allocs/op" + } + ], + "averageMetrics": { + "B/op": 12954, + "allocs/op": 687, + "ns/op": 2242283 + } + }, + { + "name": "BenchmarkEvaluateNavigationNestedLayouts", + "bucket": "end_to_end", + "samples": [ + { + "iterations": 26832, + "metrics": { + "B/op": 4448, + "allocs/op": 41, + "ns/op": 59785 + }, + "raw": "BenchmarkEvaluateNavigationNestedLayouts \t 26832\t 59785 ns/op\t 4448 B/op\t 41 allocs/op" + } + ], + "averageMetrics": { + "B/op": 4448, + "allocs/op": 41, + "ns/op": 59785 + } + } + ] + }, + { + "lane": "wasm", + "package": "./state", + "workspace": "./state", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": false, + "benchmarkCount": 0, + "error": "go test -exec C:\\Users\\mreca\\Desktop\\GoWebComponents\\tools\\go_js_wasm_exec.bat -run ^$ -bench . -benchmem -count 1 . failed: # github.com/monstercameron/GoWebComponents/state_test [github.com/monstercameron/GoWebComponents/state.test]\n.\\useatom_example_test.go:9:6: ExampleUseAtom redeclared in this block\n\t.\\example_test.go:11:6: other declaration of ExampleUseAtom\nFAIL\tgithub.com/monstercameron/GoWebComponents/state [build failed]\nFAIL", + "output": "# github.com/monstercameron/GoWebComponents/state_test [github.com/monstercameron/GoWebComponents/state.test]\n.\\useatom_example_test.go:9:6: ExampleUseAtom redeclared in this block\n\t.\\example_test.go:11:6: other declaration of ExampleUseAtom\nFAIL\tgithub.com/monstercameron/GoWebComponents/state [build failed]\nFAIL" + }, + { + "lane": "wasm", + "package": "./testkit/hooks", + "workspace": "./testkit/hooks", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkRenderHookCurrentMicroWasm", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 100000000, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10.6 + }, + "raw": "BenchmarkRenderHookCurrentMicroWasm \t100000000\t 10.60 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 10.6 + } + }, + { + "name": "BenchmarkRenderHookStateRerenderMicroWasm", + "bucket": "alloc_runtime", + "samples": [ + { + "iterations": 5896, + "metrics": { + "B/op": 3146, + "allocs/op": 35, + "ns/op": 202724 + }, + "raw": "BenchmarkRenderHookStateRerenderMicroWasm \t 5896\t 202724 ns/op\t 3146 B/op\t 35 allocs/op" + } + ], + "averageMetrics": { + "B/op": 3146, + "allocs/op": 35, + "ns/op": 202724 + } + } + ] + }, + { + "lane": "wasm", + "package": "./testkit/router", + "workspace": "./testkit/router", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkCloneURLValuesMicroWasm", + "bucket": "memory", + "samples": [ + { + "iterations": 1501446, + "metrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 952.3 + }, + "raw": "BenchmarkCloneURLValuesMicroWasm \t 1501446\t 952.3 ns/op\t 48 B/op\t 2 allocs/op" + } + ], + "averageMetrics": { + "B/op": 48, + "allocs/op": 2, + "ns/op": 952.3 + } + }, + { + "name": "BenchmarkCloneStringMapMicroWasm", + "bucket": "memory", + "samples": [ + { + "iterations": 3286479, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 341.1 + }, + "raw": "BenchmarkCloneStringMapMicroWasm \t 3286479\t 341.1 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 341.1 + } + } + ] + }, + { + "lane": "wasm", + "package": "./utils", + "workspace": "./utils", + "command": "go test -exec \u003cgoWasmExec\u003e -run ^$ -bench . -benchmem -count 1 .", + "ok": true, + "benchmarkCount": 2, + "benchmarks": [ + { + "name": "BenchmarkConfigureAndReadMemStatsSampleRateMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 100137525, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.47 + }, + "raw": "BenchmarkConfigureAndReadMemStatsSampleRateMicro \t100137525\t 11.47 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 11.47 + } + }, + { + "name": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro", + "bucket": "compute", + "samples": [ + { + "iterations": 841954, + "metrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1198 + }, + "raw": "BenchmarkConfigureDebugNamespacesAndGetStatusMicro \t 841954\t 1198 ns/op\t 0 B/op\t 0 allocs/op" + } + ], + "averageMetrics": { + "B/op": 0, + "allocs/op": 0, + "ns/op": 1198 + } + } + ] + } + ], + "scores": { + "method": "100 * geometric_mean(reference_ns / measured_ns)", + "referencePath": "./docs/benchmarks/reference.json", + "referenceGeneratedAt": "2026-03-25T15:17:41Z", + "referenceMachine": "go1.26.0 windows/amd64", + "matchedBenchmarks": 97, + "overallScore": 67, + "buckets": [ + { + "id": "compute", + "label": "Compute", + "matchedBenchmarks": 6, + "score": 82.8 + }, + { + "id": "memory", + "label": "Memory", + "matchedBenchmarks": 2, + "score": 80.3 + }, + { + "id": "alloc_runtime", + "label": "Alloc/Runtime", + "matchedBenchmarks": 71, + "score": 35.1 + }, + { + "id": "sync_concurrency", + "label": "Sync/Concurrency", + "matchedBenchmarks": 11, + "score": 73 + }, + { + "id": "end_to_end", + "label": "End-to-End", + "matchedBenchmarks": 7, + "score": 79.7 + } + ] + } +} diff --git a/docs/capabilities/capabilities.go b/docs/capabilities/capabilities.go new file mode 100644 index 00000000..ea4da1ca --- /dev/null +++ b/docs/capabilities/capabilities.go @@ -0,0 +1,270 @@ +// Package capabilities holds the curated capability table for the GoWebComponents +// framework and renders the generated capability-matrix reference page. The page +// is never hand-maintained: TestCapabilityMatrixIsGenerated regenerates it from +// the table below and fails if the committed page drifts, so the matrix always +// reflects what actually exists on disk. +package capabilities + +import "strings" + +// Capability is one row in the framework capability matrix, mapping a named +// capability to the packages that implement it, a representative public example +// slug, and the reference-manual chapter that covers it in depth. +// +// ExampleSlug is the subdirectory name under examples/public/; an empty string +// means no public example exists yet and the Example cell renders "—". +// Chapter is the filename (not path) of the markdown chapter under +// docs/REFERENCE_MANUAL/. +type Capability struct { + // Name is the human-readable capability label shown in the matrix. + Name string + // Packages lists the Go package path suffixes (relative to the module root) + // that implement this capability, e.g. []string{"ui"} or []string{"html", + // "html/shorthand"}. + Packages []string + // ExampleSlug is the name of the directory under examples/public/ that best + // demonstrates this capability. Empty means no public example exists yet. + ExampleSlug string + // Chapter is the filename of the reference-manual chapter that covers this + // capability, e.g. "04-ui-rendering-and-hooks.md". + Chapter string +} + +// Capabilities returns the curated capability table in stable reading order. +// Do not sort the slice; callers that need a different order should copy and sort. +func Capabilities() []Capability { + return []Capability{ + { + Name: "Components & hooks", + Packages: []string{"ui"}, + ExampleSlug: "counter", + Chapter: "04-ui-rendering-and-hooks.md", + }, + { + Name: "DOM refs & lifecycle", + Packages: []string{"ui", "html"}, + ExampleSlug: "dom-ref", + Chapter: "04-ui-rendering-and-hooks.md", + }, + { + Name: "HTML authoring", + Packages: []string{"html", "html/shorthand"}, + ExampleSlug: "semantic-html", + Chapter: "05-html-authoring.md", + }, + { + Name: "Typed CSS", + Packages: []string{"css", "css/u"}, + ExampleSlug: "typed-css", + Chapter: "05-html-authoring.md", + }, + { + Name: "Typed theme tokens (gwc css gen)", + Packages: []string{"css/u"}, + ExampleSlug: "typed-css-tokens-demo", + Chapter: "05-html-authoring.md", + }, + { + Name: "Markup nodes (raw HTML & SVG)", + Packages: []string{"html"}, + ExampleSlug: "raw-html", + Chapter: "05-html-authoring.md", + }, + { + Name: "Shared state & reactivity", + Packages: []string{"state"}, + ExampleSlug: "state-atoms", + Chapter: "06-state-and-reactivity.md", + }, + { + Name: "Client-side SQLite & durable state", + Packages: []string{"db/sqlite", "kvstate"}, + ExampleSlug: "sqlite-persistence", + Chapter: "06-state-and-reactivity.md", + }, + { + Name: "Data loading & mutations", + Packages: []string{"fetch"}, + ExampleSlug: "use-resource", + Chapter: "07-data-loading-and-mutations.md", + }, + { + Name: "Realtime data", + Packages: []string{"fetch"}, + ExampleSlug: "cross-tab-sync", + Chapter: "07-data-loading-and-mutations.md", + }, + { + Name: "Routing", + Packages: []string{"router"}, + ExampleSlug: "browser-router", + Chapter: "08-routing.md", + }, + { + Name: "SSR & hydration", + Packages: []string{"ui", "head"}, + ExampleSlug: "hydration", + Chapter: "09-ssr-and-hydration.md", + }, + { + Name: "Static islands", + Packages: []string{"ui"}, + ExampleSlug: "static-islands", + Chapter: "09-ssr-and-hydration.md", + }, + { + Name: "Browser interop & workers", + Packages: []string{"interop"}, + ExampleSlug: "browser-interop", + Chapter: "10-browser-interop-and-workers.md", + }, + { + Name: "Forms & accessibility", + Packages: []string{"ui"}, + ExampleSlug: "form-accessibility", + Chapter: "11-forms-accessibility-and-i18n.md", + }, + { + Name: "Shared client/server validation", + Packages: []string{"validate", "ui"}, + ExampleSlug: "shared-form-validation", + Chapter: "11-forms-accessibility-and-i18n.md", + }, + { + Name: "Internationalization", + Packages: []string{"i18n"}, + ExampleSlug: "locale-switcher", + Chapter: "11-forms-accessibility-and-i18n.md", + }, + { + Name: "Devtools & diagnostics", + Packages: []string{"devtools"}, + ExampleSlug: "devtools-panel", + Chapter: "12-devtools-testing-and-observability.md", + }, + { + Name: "PWA & offline", + Packages: []string{"pwa"}, + ExampleSlug: "progressive-web-app-offline-cache", + Chapter: "13-assets-deployment-and-pwa.md", + }, + { + Name: "Feature flags", + Packages: []string{"flags"}, + ExampleSlug: "feature-flags", + Chapter: "06-state-and-reactivity.md", + }, + { + Name: "Fine-grained signals", + Packages: []string{"state"}, + ExampleSlug: "fine-grained-signal", + Chapter: "06-state-and-reactivity.md", + }, + { + Name: "Server functions (//gwc:server)", + Packages: []string{"serverfn"}, + ExampleSlug: "", + Chapter: "07-data-loading-and-mutations.md", + }, + { + Name: "Query cache & mutations", + Packages: []string{"query", "ui"}, + ExampleSlug: "use-query", + Chapter: "07-data-loading-and-mutations.md", + }, + { + Name: "Generative UI (agent-native)", + Packages: []string{"agentui"}, + ExampleSlug: "agentui-registry", + Chapter: "07-data-loading-and-mutations.md", + }, + { + Name: "Whole-stack one-binary deploy", + Packages: []string{"wholestack", "serverfn"}, + ExampleSlug: "", + Chapter: "13-assets-deployment-and-pwa.md", + }, + { + Name: "Local-first CRDT sync", + Packages: []string{"localfirst"}, + ExampleSlug: "localfirst-crdt", + Chapter: "06-state-and-reactivity.md", + }, + { + Name: "Time-travel devtools", + Packages: []string{"timetravel"}, + ExampleSlug: "timetravel-devpanel", + Chapter: "12-devtools-testing-and-observability.md", + }, + { + Name: "Animations & FLIP", + Packages: []string{"anim"}, + ExampleSlug: "flip-keyed-list", + Chapter: "04-ui-rendering-and-hooks.md", + }, + { + Name: "Two-way binding", + Packages: []string{"html"}, + ExampleSlug: "bind-to", + Chapter: "05-html-authoring.md", + }, + { + Name: "Named slots", + Packages: []string{"html/shorthand"}, + ExampleSlug: "named-slots", + Chapter: "05-html-authoring.md", + }, + { + Name: "Typed search params", + Packages: []string{"router"}, + ExampleSlug: "typed-decode-query", + Chapter: "08-routing.md", + }, + { + Name: "Typed i18n message accessors", + Packages: []string{"i18n"}, + ExampleSlug: "", + Chapter: "11-forms-accessibility-and-i18n.md", + }, + } +} + +// RenderPage renders the capability-matrix reference page as a GitHub-Flavored +// Markdown string from the provided capability rows. Row order is preserved. +// When a Capability's ExampleSlug is empty the Example cell renders "—" rather +// than a broken link. +func RenderPage(parseCaps []Capability) string { + var parseBuilder strings.Builder + + parseBuilder.WriteString("# Capability Matrix\n\n") + parseBuilder.WriteString("> Generated from `docs/capabilities/capabilities.go`.") + parseBuilder.WriteString(" Do not edit by hand;") + parseBuilder.WriteString(" run `CAPABILITIES_WRITE=1 go test ./docs/capabilities/` to regenerate.\n\n") + + parseBuilder.WriteString("| Capability | Package(s) | Example | Chapter |\n") + parseBuilder.WriteString("| --- | --- | --- | --- |\n") + + for _, parseCap := range parseCaps { + // Package(s) column: each package as inline code, joined by ", ". + parsePackageParts := make([]string, len(parseCap.Packages)) + for parseIdx, parsePkg := range parseCap.Packages { + parsePackageParts[parseIdx] = "`" + parsePkg + "`" + } + parsePackageCell := strings.Join(parsePackageParts, ", ") + + // Example column: link when slug is set, em-dash otherwise. + var parseExampleCell string + if parseCap.ExampleSlug != "" { + parseExampleCell = "[" + parseCap.ExampleSlug + "](../../examples/public/" + parseCap.ExampleSlug + "/)" + } else { + parseExampleCell = "—" + } + + // Chapter column: link to the chapter file in the same directory. + parseChapterCell := "[" + parseCap.Chapter + "](" + parseCap.Chapter + ")" + + parseBuilder.WriteString("| " + parseCap.Name + " | " + parsePackageCell + " | " + parseExampleCell + " | " + parseChapterCell + " |\n") + } + + return parseBuilder.String() +} diff --git a/docs/capabilities/capabilities_test.go b/docs/capabilities/capabilities_test.go new file mode 100644 index 00000000..d097a6dc --- /dev/null +++ b/docs/capabilities/capabilities_test.go @@ -0,0 +1,85 @@ +package capabilities + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +// repoRoot resolves the module root by walking up from the test working +// directory until a directory containing go.mod is found. +func repoRoot(parseT *testing.T) string { + parseT.Helper() + parseWd, parseErr := os.Getwd() + if parseErr != nil { + parseT.Fatalf("getwd: %v", parseErr) + } + parseDir := parseWd + for range 12 { + if _, parseStatErr := os.Stat(filepath.Join(parseDir, "go.mod")); parseStatErr == nil { + return parseDir + } + parseParent := filepath.Dir(parseDir) + if parseParent == parseDir { + break + } + parseDir = parseParent + } + parseT.Fatalf("module root (go.mod) not found from %s", parseWd) + return "" +} + +// TestCapabilityReferencesResolve is the filesystem guard: for every Capability +// row in the curated table, it asserts that the example directory exists on disk +// (when ExampleSlug is non-empty) and that the chapter file exists under +// docs/REFERENCE_MANUAL/. This is the check that fails CI the moment a slug or +// chapter filename is renamed without updating the table. +func TestCapabilityReferencesResolve(parseT *testing.T) { + parseRoot := repoRoot(parseT) + parseCaps := Capabilities() + if len(parseCaps) == 0 { + parseT.Fatal("Capabilities() returned an empty slice; the table is missing") + } + for _, parseCap := range parseCaps { + parseT.Run(parseCap.Name, func(parseInner *testing.T) { + if parseCap.ExampleSlug != "" { + parseExampleDir := filepath.Join(parseRoot, "examples", "public", parseCap.ExampleSlug) + if _, parseStatErr := os.Stat(parseExampleDir); parseStatErr != nil { + parseInner.Errorf("example directory %q not found on disk (ExampleSlug=%q): %v", + parseExampleDir, parseCap.ExampleSlug, parseStatErr) + } + } + parseChapterPath := filepath.Join(parseRoot, "docs", "REFERENCE_MANUAL", parseCap.Chapter) + if _, parseStatErr := os.Stat(parseChapterPath); parseStatErr != nil { + parseInner.Errorf("chapter file %q not found on disk (Chapter=%q): %v", + parseChapterPath, parseCap.Chapter, parseStatErr) + } + }) + } +} + +// TestCapabilityMatrixIsGenerated is the drift guard: the committed page must +// byte-match the output of RenderPage(Capabilities()). Run with +// CAPABILITIES_WRITE=1 to regenerate after updating the capability table. +func TestCapabilityMatrixIsGenerated(parseT *testing.T) { + parseRoot := repoRoot(parseT) + parseExpected := RenderPage(Capabilities()) + parsePath := filepath.Join(parseRoot, "docs", "REFERENCE_MANUAL", "capability-matrix.md") + + if os.Getenv("CAPABILITIES_WRITE") != "" { + if parseWriteErr := os.WriteFile(parsePath, []byte(parseExpected), 0o644); parseWriteErr != nil { + parseT.Fatalf("write capability matrix page: %v", parseWriteErr) + } + parseT.Logf("regenerated %s", parsePath) + return + } + + parseActual, parseReadErr := os.ReadFile(parsePath) + if parseReadErr != nil { + parseT.Fatalf("read capability matrix page (regenerate with CAPABILITIES_WRITE=1 go test ./docs/capabilities/): %v", parseReadErr) + } + if strings.ReplaceAll(string(parseActual), "\r\n", "\n") != parseExpected { + parseT.Fatalf("capability-matrix.md is stale; regenerate with CAPABILITIES_WRITE=1 go test ./docs/capabilities/") + } +} diff --git a/docs/deletemesoon/example-preview.html b/docs/deletemesoon/example-preview.html new file mode 100644 index 00000000..f8282973 --- /dev/null +++ b/docs/deletemesoon/example-preview.html @@ -0,0 +1,29 @@ + + + + + + React Preview + + + + + + +
+ + + \ No newline at end of file diff --git a/docs/doclint/commands.go b/docs/doclint/commands.go new file mode 100644 index 00000000..5535ce9e --- /dev/null +++ b/docs/doclint/commands.go @@ -0,0 +1,478 @@ +package doclint + +import ( + "bufio" + "context" + "errors" + "fmt" + "os" + "os/exec" + "path/filepath" + "sort" + "strconv" + "strings" + "time" +) + +// GwcCommandRef is one documented gwc command line found in a Markdown shell block. +type GwcCommandRef struct { + DocPath string + Line int + Raw string + Args []string +} + +// GwcCommandPlan is the executable or explicitly skipped plan for one documented command. +type GwcCommandPlan struct { + Ref GwcCommandRef + Args []string + SkipReason string +} + +// GwcCommandResult records one attempted or skipped documented command. +type GwcCommandResult struct { + Plan GwcCommandPlan + Output string + Err error +} + +// GwcCommandRunSummary is the result of the command-execution doclint lane. +type GwcCommandRunSummary struct { + Executed []GwcCommandResult + Skipped []GwcCommandResult +} + +// CommandRunner executes one command from one working directory with extra environment variables. +type CommandRunner func(context.Context, string, []string, string, []string) (string, error) + +// GwcCommandRunOptions configures the documented-command execution lane. +type GwcCommandRunOptions struct { + OutputRoot string + Timeout time.Duration + MaxCommands int + Runner CommandRunner +} + +var finiteGwcCommands = map[string]bool{ + "doctor": true, + "env": true, + "examples": true, + "files": true, + "build": true, +} + +var longRunningGwcCommands = map[string]string{ + "dev": "dev starts a long-running server unless -dry-run is present", + "serve": "serve starts a long-running server", + "dashboard": "dashboard starts an interactive status UI", +} + +var heavyGwcCommands = map[string]string{ + "bench": "bench is a benchmark lane, not a doc smoke command", + "release": "release writes a full artifact tree and can run smoke validation", + "test": "test may run broad wasm/browser lanes", + "verify": "verify may run tests and full app validation", + "wasm": "wasm subcommands may build and compare artifacts", + "deploy": "deploy needs pre-existing release artifacts and target policy", + "prerender": "prerender can execute app-specific rendering work", +} + +var interactiveGwcCommands = map[string]string{ + "start": "start is interactive unless a preset flow is fully specified", + "bootstrap": "bootstrap can enter interactive scaffolding flows", + "seed": "seed is app-specific and can mutate local data stores", + "import": "import converts user-supplied source files", + "upgrade": "upgrade mutates project files", + "migrate": "migrate can rewrite source files", +} + +// ScanDocGwcCommands returns gwc command lines from Markdown shell blocks. +func ScanDocGwcCommands(parseRoot string) ([]GwcCommandRef, error) { + var parseRefs []GwcCommandRef + parseErr := filepath.Walk(parseRoot, func(parsePath string, parseInfo os.FileInfo, parseWalkErr error) error { + if parseWalkErr != nil { + return parseWalkErr + } + if parseInfo.IsDir() { + if dirsSkipped[parseInfo.Name()] { + return filepath.SkipDir + } + if parseInfo.Name() == "pkg" && strings.Contains(filepath.ToSlash(parsePath), "browser-compiler") { + return filepath.SkipDir + } + return nil + } + if strings.ToLower(filepath.Ext(parsePath)) != ".md" { + return nil + } + parseRel, parseRelErr := filepath.Rel(parseRoot, parsePath) + if parseRelErr != nil { + return parseRelErr + } + parseRelSlash := filepath.ToSlash(parseRel) + if strings.HasPrefix(parseRelSlash, snapshotDocDir) { + return nil + } + parseFileRefs, parseScanErr := scanDocGwcCommandFile(parsePath, parseRelSlash) + if parseScanErr != nil { + return parseScanErr + } + parseRefs = append(parseRefs, parseFileRefs...) + return nil + }) + if parseErr != nil { + return nil, parseErr + } + sort.Slice(parseRefs, func(parseI, parseJ int) bool { + if parseRefs[parseI].DocPath == parseRefs[parseJ].DocPath { + return parseRefs[parseI].Line < parseRefs[parseJ].Line + } + return parseRefs[parseI].DocPath < parseRefs[parseJ].DocPath + }) + return parseRefs, nil +} + +func scanDocGwcCommandFile(parsePath, parseDocRel string) ([]GwcCommandRef, error) { + parseFile, parseErr := os.Open(parsePath) + if parseErr != nil { + return nil, parseErr + } + defer parseFile.Close() + + var parseRefs []GwcCommandRef + parseScanner := bufio.NewScanner(parseFile) + parseScanner.Buffer(make([]byte, 0, 64*1024), 1024*1024) + parseInFence := false + parseBlockIsShell := false + parseLineNo := 0 + for parseScanner.Scan() { + parseLineNo++ + parseLine := parseScanner.Text() + if parseMatch := fenceOpen.FindStringSubmatch(parseLine); parseMatch != nil { + if parseInFence { + parseInFence = false + parseBlockIsShell = false + } else { + parseInFence = true + parseBlockIsShell = shellLangs[strings.ToLower(parseMatch[1])] + } + continue + } + if !parseInFence || (!parseBlockIsShell && !looksLikeCommand(parseLine)) { + continue + } + parseArgs, parseOk := parseGwcCommandArgs(parseLine) + if !parseOk { + continue + } + parseRefs = append(parseRefs, GwcCommandRef{ + DocPath: parseDocRel, + Line: parseLineNo, + Raw: strings.TrimSpace(parseLine), + Args: parseArgs, + }) + } + if parseErr := parseScanner.Err(); parseErr != nil { + return nil, parseErr + } + return parseRefs, nil +} + +func parseGwcCommandArgs(parseLine string) ([]string, bool) { + parseFields, parseErr := splitShellFields(stripShellPrompt(parseLine)) + if parseErr != nil || len(parseFields) == 0 { + return nil, false + } + if strings.EqualFold(parseFields[0], "go") && + len(parseFields) >= 3 && + strings.EqualFold(parseFields[1], "run") && + isToolsGwcToken(parseFields[2]) { + return normalizeCommandPathArgs(parseFields[3:]), true + } + if strings.EqualFold(parseFields[0], "gwc") { + return normalizeCommandPathArgs(parseFields[1:]), true + } + return nil, false +} + +func stripShellPrompt(parseLine string) string { + parseTrimmed := strings.TrimSpace(parseLine) + for _, parsePrefix := range []string{"PS> ", "$ ", "> "} { + if after, ok := strings.CutPrefix(parseTrimmed, parsePrefix); ok { + return strings.TrimSpace(after) + } + } + return parseTrimmed +} + +func splitShellFields(parseLine string) ([]string, error) { + var parseFields []string + var parseBuilder strings.Builder + var parseQuote rune + parseFlush := func() { + if parseBuilder.Len() == 0 { + return + } + parseFields = append(parseFields, parseBuilder.String()) + parseBuilder.Reset() + } + for _, parseRune := range parseLine { + if parseQuote != 0 { + if parseRune == parseQuote { + parseQuote = 0 + continue + } + parseBuilder.WriteRune(parseRune) + continue + } + switch parseRune { + case '\'', '"': + parseQuote = parseRune + case ' ', '\t': + parseFlush() + default: + parseBuilder.WriteRune(parseRune) + } + } + if parseQuote != 0 { + return nil, fmt.Errorf("unterminated quoted command field in %q", parseLine) + } + parseFlush() + return parseFields, nil +} + +func isToolsGwcToken(parseToken string) bool { + parseNormalized := strings.TrimPrefix(filepath.ToSlash(strings.Trim(parseToken, "\"'")), "./") + return parseNormalized == "tools/gwc" +} + +func normalizeCommandPathArgs(parseArgs []string) []string { + parseOut := make([]string, 0, len(parseArgs)) + for _, parseArg := range parseArgs { + parseOut = append(parseOut, normalizeDocCommandArg(parseArg)) + } + return parseOut +} + +func normalizeDocCommandArg(parseArg string) string { + parseTrimmed := strings.Trim(parseArg, "\"'") + if strings.Contains(parseTrimmed, `\`) { + parseTrimmed = filepath.ToSlash(parseTrimmed) + } + if strings.HasPrefix(parseTrimmed, "./") || strings.HasPrefix(parseTrimmed, "../") { + return filepath.FromSlash(parseTrimmed) + } + return parseTrimmed +} + +// PlanDocGwcCommands classifies documented commands into finite executable commands and explicit skips. +func PlanDocGwcCommands(parseRefs []GwcCommandRef, parseOutputRoot string) []GwcCommandPlan { + parsePlans := make([]GwcCommandPlan, 0, len(parseRefs)) + for _, parseRef := range parseRefs { + parsePlan := planDocGwcCommand(parseRef, parseOutputRoot) + parsePlans = append(parsePlans, parsePlan) + } + return parsePlans +} + +func planDocGwcCommand(parseRef GwcCommandRef, parseOutputRoot string) GwcCommandPlan { + parsePlan := GwcCommandPlan{Ref: parseRef, Args: append([]string(nil), parseRef.Args...)} + if len(parsePlan.Args) == 0 { + parsePlan.SkipReason = "command placeholder has no gwc subcommand" + return parsePlan + } + if parseHasPlaceholderArg(parsePlan.Args) { + parsePlan.SkipReason = "command contains placeholder arguments" + return parsePlan + } + parseCommand := strings.ToLower(parsePlan.Args[0]) + if isHelpCommand(parsePlan.Args) { + return parsePlan + } + if parseReason, parseOk := longRunningGwcCommands[parseCommand]; parseOk { + if parseCommand == "dev" && hasFlag(parsePlan.Args, "-dry-run") { + return parsePlan + } + parsePlan.SkipReason = parseReason + return parsePlan + } + if parseReason, parseOk := heavyGwcCommands[parseCommand]; parseOk { + parsePlan.SkipReason = parseReason + return parsePlan + } + if parseReason, parseOk := interactiveGwcCommands[parseCommand]; parseOk { + parsePlan.SkipReason = parseReason + return parsePlan + } + if !finiteGwcCommands[parseCommand] { + parsePlan.SkipReason = "unknown or app-specific gwc command" + return parsePlan + } + if parseCommand == "doctor" && hasFlag(parsePlan.Args, "-audit") { + parsePlan.SkipReason = "doctor -audit is broader than a command smoke check" + return parsePlan + } + if parseCommand == "doctor" { + parsePlan.SkipReason = "doctor depends on local toolchain and browser prerequisites" + return parsePlan + } + if parseCommand == "examples" { + if hasFlag(parsePlan.Args, "-export-static-catalog") { + if parseOutputRoot == "" { + parsePlan.SkipReason = "examples export-static-catalog needs an output sandbox" + return parsePlan + } + parsePlan.Args = rewriteFlagOutputArg(parsePlan.Args, "-export-static-catalog", filepath.Join(parseOutputRoot, stableCommandOutputName(parseRef)+".json")) + return parsePlan + } + parsePlan.SkipReason = "examples starts a long-running server unless exporting the catalog" + return parsePlan + } + if parseCommand == "build" { + if hasFlagValue(parsePlan.Args, "-profile", "tinygo") { + parsePlan.SkipReason = "tinygo profile requires an optional external toolchain" + return parsePlan + } + if parseOutputRoot == "" { + parsePlan.SkipReason = "build command needs an output sandbox" + return parsePlan + } + parsePlan.Args = rewriteBuildOutputArg(parsePlan.Args, parseOutputRoot, parseRef) + } + return parsePlan +} + +func parseHasPlaceholderArg(parseArgs []string) bool { + for _, parseArg := range parseArgs { + parseLower := strings.ToLower(filepath.ToSlash(parseArg)) + if strings.Contains(parseLower, "<") || strings.Contains(parseLower, ">") || + strings.Contains(parseLower, "...") || isPlaceholder(parseLower) || + parseLower == "./main.go" || parseLower == ".\\main.go" || parseLower == "main.go" || + parseLower == "./static" || parseLower == ".\\static" || parseLower == "./design/landing.html" { + return true + } + } + return false +} + +func isHelpCommand(parseArgs []string) bool { + return hasFlag(parseArgs, "-h") || hasFlag(parseArgs, "--help") || hasFlag(parseArgs, "help") +} + +func hasFlag(parseArgs []string, parseFlag string) bool { + for _, parseArg := range parseArgs { + if strings.EqualFold(parseArg, parseFlag) { + return true + } + } + return false +} + +func hasFlagValue(parseArgs []string, parseFlag string, parseValue string) bool { + for parseIndex, parseArg := range parseArgs { + if !strings.EqualFold(parseArg, parseFlag) || parseIndex+1 >= len(parseArgs) { + continue + } + if strings.EqualFold(parseArgs[parseIndex+1], parseValue) { + return true + } + } + return false +} + +func rewriteBuildOutputArg(parseArgs []string, parseOutputRoot string, parseRef GwcCommandRef) []string { + parseOut := append([]string(nil), parseArgs...) + parseOutputPath := filepath.Join(parseOutputRoot, stableCommandOutputName(parseRef)+".wasm") + return rewriteFlagOutputArg(parseOut, "-out", parseOutputPath) +} + +func rewriteFlagOutputArg(parseArgs []string, parseFlag string, parseOutputPath string) []string { + parseOut := append([]string(nil), parseArgs...) + for parseIndex, parseArg := range parseOut { + if strings.EqualFold(parseArg, parseFlag) && parseIndex+1 < len(parseOut) { + parseOut[parseIndex+1] = parseOutputPath + return parseOut + } + } + return append(parseOut, parseFlag, parseOutputPath) +} + +func stableCommandOutputName(parseRef GwcCommandRef) string { + parseName := strings.NewReplacer("/", "_", "\\", "_", ".", "_", ":", "_").Replace(parseRef.DocPath) + return parseName + "_" + strconv.Itoa(parseRef.Line) +} + +// RunDocGwcCommands executes the finite planned commands with a network-off Go environment. +func RunDocGwcCommands(parseRoot string, parseOptions GwcCommandRunOptions) (GwcCommandRunSummary, error) { + parseRefs, parseErr := ScanDocGwcCommands(parseRoot) + if parseErr != nil { + return GwcCommandRunSummary{}, parseErr + } + if len(parseRefs) == 0 { + return GwcCommandRunSummary{}, errors.New("no documented gwc commands found") + } + parseOutputRoot := parseOptions.OutputRoot + if parseOutputRoot == "" { + parseOutputRoot = filepath.Join(os.TempDir(), "gwc-doclint-commands") + } + if parseErr2 := os.MkdirAll(parseOutputRoot, 0o755); parseErr2 != nil { + return GwcCommandRunSummary{}, parseErr2 + } + parseTimeout := parseOptions.Timeout + if parseTimeout <= 0 { + parseTimeout = 2 * time.Minute + } + parseMaxCommands := parseOptions.MaxCommands + if parseMaxCommands <= 0 { + parseMaxCommands = 25 + } + parseRunner := parseOptions.Runner + if parseRunner == nil { + parseRunner = ExecCommandRunner + } + parsePlans := PlanDocGwcCommands(parseRefs, parseOutputRoot) + parseSummary := GwcCommandRunSummary{} + parseExecutedCount := 0 + parseEnv := docCommandGoEnv() + for _, parsePlan := range parsePlans { + if parsePlan.SkipReason != "" { + parseSummary.Skipped = append(parseSummary.Skipped, GwcCommandResult{Plan: parsePlan}) + continue + } + if parseExecutedCount >= parseMaxCommands { + parsePlan.SkipReason = "max command execution budget reached" + parseSummary.Skipped = append(parseSummary.Skipped, GwcCommandResult{Plan: parsePlan}) + continue + } + parseExecutedCount++ + parseCtx, parseCancel := context.WithTimeout(context.Background(), parseTimeout) + parseOutput, parseRunErr := parseRunner(parseCtx, parseRoot, parseEnv, "go", append([]string{"run", "./tools/gwc"}, parsePlan.Args...)) + parseCancel() + parseSummary.Executed = append(parseSummary.Executed, GwcCommandResult{ + Plan: parsePlan, + Output: parseOutput, + Err: parseRunErr, + }) + } + return parseSummary, nil +} + +// ExecCommandRunner runs one command and returns combined stdout/stderr. +func ExecCommandRunner(parseCtx context.Context, parseDir string, parseEnv []string, parseName string, parseArgs []string) (string, error) { + parseCmd := exec.CommandContext(parseCtx, parseName, parseArgs...) + parseCmd.Dir = parseDir + parseCmd.Env = append(os.Environ(), parseEnv...) + parseOutput, parseErr := parseCmd.CombinedOutput() + if parseCtx.Err() != nil { + return string(parseOutput), parseCtx.Err() + } + return string(parseOutput), parseErr +} + +func docCommandGoEnv() []string { + return []string{ + "GOPROXY=off", + "GOSUMDB=off", + "GONOSUMDB=*", + } +} diff --git a/docs/doclint/commands_doclintcmd_test.go b/docs/doclint/commands_doclintcmd_test.go new file mode 100644 index 00000000..78658704 --- /dev/null +++ b/docs/doclint/commands_doclintcmd_test.go @@ -0,0 +1,54 @@ +//go:build doclintcmd + +package doclint + +import ( + "sort" + "strings" + "testing" + "time" +) + +// TestDocsGwcCommandsExecute is the opt-in command-execution lane for docs. +// Run it explicitly with: +// +// go test -tags doclintcmd ./docs/doclint -run TestDocsGwcCommandsExecute -count=1 -v -timeout 10m +func TestDocsGwcCommandsExecute(t *testing.T) { + root := repoRoot(t) + summary, err := RunDocGwcCommands(root, GwcCommandRunOptions{ + OutputRoot: t.TempDir(), + Timeout: 2 * time.Minute, + MaxCommands: 1000, + }) + if err != nil { + t.Fatalf("run documented gwc commands: %v", err) + } + if len(summary.Executed) == 0 { + t.Fatal("no documented gwc commands were executable; the command planner may be too strict") + } + skipReasons := map[string]int{} + for _, result := range summary.Skipped { + skipReasons[result.Plan.SkipReason]++ + } + + var failures []string + for _, result := range summary.Executed { + if result.Err == nil { + continue + } + output := strings.TrimSpace(result.Output) + if len(output) > 800 { + output = output[:800] + "...(truncated)" + } + failures = append(failures, result.Plan.Ref.DocPath+":"+itoa(result.Plan.Ref.Line)+" -> "+ + strings.Join(result.Plan.Args, " ")+"\n"+result.Err.Error()+"\n"+output) + } + if len(failures) > 0 { + sort.Strings(failures) + t.Fatalf("documented gwc command execution failed for %d command(s):\n%s", len(failures), strings.Join(failures, "\n\n")) + } + t.Logf("executed %d documented gwc commands; skipped %d with explicit reasons", len(summary.Executed), len(summary.Skipped)) + for reason, count := range skipReasons { + t.Logf("skipped %d: %s", count, reason) + } +} diff --git a/docs/doclint/commands_test.go b/docs/doclint/commands_test.go new file mode 100644 index 00000000..835aa545 --- /dev/null +++ b/docs/doclint/commands_test.go @@ -0,0 +1,135 @@ +package doclint + +import ( + "context" + "errors" + "path/filepath" + "strings" + "testing" +) + +func TestScanDocGwcCommandsParsesFencedCommands(t *testing.T) { + root := t.TempDir() + mustWrite(t, filepath.Join(root, "README.md"), "# Doc\n\n```powershell\n"+ + "go run ./tools/gwc build -app \".\\examples\\public\\counter\\main.go\" -profile development\n"+ + "gwc dev -app ./examples/public/counter/main.go -dry-run\n"+ + "go test ./...\n"+ + "```\n\n```go\n"+ + "func main() { println(\"gwc dev is prose here\") }\n"+ + "```\n") + + refs, err := ScanDocGwcCommands(root) + if err != nil { + t.Fatalf("scan commands: %v", err) + } + if len(refs) != 2 { + t.Fatalf("expected 2 gwc command refs, got %d: %+v", len(refs), refs) + } + if refs[0].Args[0] != "build" || refs[1].Args[0] != "dev" { + t.Fatalf("unexpected command order: %+v", refs) + } + if !strings.Contains(filepath.ToSlash(refs[0].Args[2]), "examples/public/counter/main.go") { + t.Fatalf("expected windows path to be normalized, got args %+v", refs[0].Args) + } +} + +func TestPlanDocGwcCommandsClassifiesAndSandboxesOutputs(t *testing.T) { + outRoot := t.TempDir() + refs := []GwcCommandRef{ + {DocPath: "README.md", Line: 10, Args: []string{"build", "-app", filepath.FromSlash("./examples/public/counter/main.go"), "-out", filepath.FromSlash("./bin/counter.wasm")}}, + {DocPath: "README.md", Line: 11, Args: []string{"build", "-app", filepath.FromSlash("./main.go")}}, + {DocPath: "README.md", Line: 12, Args: []string{"build", "-app", filepath.FromSlash("./examples/public/counter/main.go"), "-profile", "tinygo"}}, + {DocPath: "README.md", Line: 13, Args: []string{"dev", "-app", filepath.FromSlash("./examples/public/counter/main.go")}}, + {DocPath: "README.md", Line: 14, Args: []string{"dev", "-app", filepath.FromSlash("./examples/public/counter/main.go"), "-dry-run"}}, + {DocPath: "README.md", Line: 15, Args: []string{"examples"}}, + {DocPath: "README.md", Line: 16, Args: []string{"examples", "-export-static-catalog", filepath.FromSlash("./bin/catalog.json")}}, + {DocPath: "README.md", Line: 17, Args: []string{"doctor"}}, + {DocPath: "README.md", Line: 18, Args: []string{"doctor", "-h"}}, + {DocPath: "README.md", Line: 19, Args: []string{"release", "-app", filepath.FromSlash("./examples/public/counter/main.go")}}, + } + + plans := PlanDocGwcCommands(refs, outRoot) + assertPlanExecutable(t, plans[0], "-out", outRoot) + assertPlanSkipped(t, plans[1], "placeholder") + assertPlanSkipped(t, plans[2], "tinygo") + assertPlanSkipped(t, plans[3], "long-running") + if plans[4].SkipReason != "" { + t.Fatalf("expected dev -dry-run to be executable, got skip %q", plans[4].SkipReason) + } + assertPlanSkipped(t, plans[5], "long-running") + assertPlanExecutable(t, plans[6], "-export-static-catalog", outRoot) + assertPlanSkipped(t, plans[7], "prerequisites") + if plans[8].SkipReason != "" { + t.Fatalf("expected help command to be executable, got skip %q", plans[8].SkipReason) + } + assertPlanSkipped(t, plans[9], "release") +} + +func TestRunDocGwcCommandsWithFakeRunnerReportsFailures(t *testing.T) { + root := t.TempDir() + mustWrite(t, filepath.Join(root, "README.md"), "# Doc\n\n```powershell\n"+ + "go run ./tools/gwc files -root . -ext go\n"+ + "go run ./tools/gwc build -app .\\examples\\public\\counter\\main.go\n"+ + "go run ./tools/gwc dev -app .\\examples\\public\\counter\\main.go\n"+ + "```\n") + + var ran []string + runner := func(ctx context.Context, dir string, env []string, name string, args []string) (string, error) { + _ = ctx + if dir != root { + t.Fatalf("expected command dir %q, got %q", root, dir) + } + if name != "go" { + t.Fatalf("expected go runner, got %q", name) + } + joined := strings.Join(args, " ") + ran = append(ran, joined) + if strings.Contains(joined, " build ") { + return "build failed", errors.New("planted failure") + } + return "ok", nil + } + + summary, err := RunDocGwcCommands(root, GwcCommandRunOptions{ + OutputRoot: t.TempDir(), + Runner: runner, + }) + if err != nil { + t.Fatalf("run doc commands: %v", err) + } + if len(summary.Executed) != 2 { + t.Fatalf("expected 2 executed commands, got %d: %+v", len(summary.Executed), summary.Executed) + } + if len(summary.Skipped) != 1 || !strings.Contains(summary.Skipped[0].Plan.SkipReason, "long-running") { + t.Fatalf("expected dev command to be skipped as long-running, got %+v", summary.Skipped) + } + if summary.Executed[1].Err == nil || !strings.Contains(summary.Executed[1].Output, "build failed") { + t.Fatalf("expected planted build failure to be reported, got %+v", summary.Executed[1]) + } + if len(ran) != 2 || !strings.Contains(ran[1], "-out") { + t.Fatalf("expected build command to be run with sandboxed -out, ran %+v", ran) + } +} + +func assertPlanSkipped(t *testing.T, plan GwcCommandPlan, want string) { + t.Helper() + if !strings.Contains(plan.SkipReason, want) { + t.Fatalf("expected skip reason containing %q for %+v, got %q", want, plan.Ref.Args, plan.SkipReason) + } +} + +func assertPlanExecutable(t *testing.T, plan GwcCommandPlan, outputFlag string, outRoot string) { + t.Helper() + if plan.SkipReason != "" { + t.Fatalf("expected executable plan for %+v, got skip %q", plan.Ref.Args, plan.SkipReason) + } + for i, arg := range plan.Args { + if arg == outputFlag && i+1 < len(plan.Args) { + if !strings.HasPrefix(plan.Args[i+1], outRoot) { + t.Fatalf("expected %s output under %q, got args %+v", outputFlag, outRoot, plan.Args) + } + return + } + } + t.Fatalf("expected output flag %s in args %+v", outputFlag, plan.Args) +} diff --git a/docs/doclint/doclint.go b/docs/doclint/doclint.go new file mode 100644 index 00000000..9774056b --- /dev/null +++ b/docs/doclint/doclint.go @@ -0,0 +1,322 @@ +// Package doclint is a documentation drift guard. +// +// It scans tracked Markdown files for repository-relative paths used as inputs +// to commands in fenced code blocks and reports any that no longer resolve on +// disk. It exists to prevent the specific class of staleness that broke the +// front-door quickstart: an example was relocated from examples/01-counter to +// examples/public/counter, but every copy-paste `gwc` command in the README, +// the getting-started chapter, and AGENTS.md kept pointing at the dead path, so +// a fresh evaluator's first command failed on a clean checkout. +// +// The guard is deliberately high precision rather than exhaustive. It only +// inspects tokens inside fenced code blocks, only treats a token as a +// repo-relative path when its first segment is an existing top-level repo +// entry, and skips command outputs and obvious user-project placeholders. The +// goal is zero false positives so the lane can fail a build without becoming +// noise that gets disabled. +package doclint + +import ( + "bufio" + "os" + "path/filepath" + "regexp" + "strings" +) + +// PathRef is one repo-relative path reference found inside a doc command block. +type PathRef struct { + // DocPath is the repo-relative path of the Markdown file that contains it. + DocPath string + // Line is the 1-based line number of the reference within that file. + Line int + // Raw is the token exactly as written in the doc (Windows or POSIX style). + Raw string + // Rel is the normalized, forward-slash, repo-relative path to resolve. + Rel string +} + +// dirsSkipped are subtrees the guard never descends into: VCS metadata, vendored +// or generated trees, and the historical example-site snapshot docs that +// intentionally preserve the old numbered catalog for the record. +var dirsSkipped = map[string]bool{ + ".git": true, + "node_modules": true, + "third_party": true, + "bin": true, + "vendor": true, + "site-dist": true, +} + +// snapshotDocDir is the one docs subtree that is an archival capture rather than +// living instructions, so its older paths must not fail the guard. +const snapshotDocDir = "examples/public-examples-site/assets/docs" + +// outputFlags precede command arguments that name where output is written, so +// the referenced path is not expected to exist before the command runs. +var outputFlags = map[string]bool{ + "-o": true, + "-out": true, + "-output": true, + "-out-dir": true, + "-outdir": true, + "-export-static-catalog": true, +} + +// fenceOpen matches a fenced code block delimiter and captures the optional +// language hint that follows the opening backticks. +var fenceOpen = regexp.MustCompile("^\\s*```+\\s*([A-Za-z0-9_+-]*)") + +// shellLangs are the fenced-block languages whose contents are commands. Only +// these (plus unlabeled blocks that clearly start with a command verb) are +// scanned for path arguments, so directory-layout listings (```text) and code +// samples with URL string literals (```go, ```json) never produce false hits. +var shellLangs = map[string]bool{ + "powershell": true, "pwsh": true, "ps1": true, + "bash": true, "sh": true, "shell": true, "zsh": true, + "console": true, "bat": true, "cmd": true, +} + +// commandVerbs lead a real command line, used to admit unlabeled fenced blocks +// without admitting prose or code. +var commandVerbs = []string{ + "go ", "gwc ", "./tools", ".\\tools", "set-location", "new-item", + "npx ", "node ", "go.exe", +} + +// pathToken captures dot-anchored relative paths (./x, .\x) and bare +// examples/... or tools/... style segmented paths used as command arguments. +var pathToken = regexp.MustCompile(`(?:\.[\\/]|\b)(?:[\w.@-]+[\\/])+[\w.@-]+`) + +// placeholderHints flag tokens that are illustrative stand-ins for a user's own +// project, not real repo paths, so they are skipped rather than resolved. +var placeholderHints = []string{ + "path\\to", "path/to", "your-app", "my-app", "<", "...", "layout\\main.go", +} + +// FindRepoRoot walks up from start until it finds the directory containing +// go.mod, returning the module root. It returns ok=false if none is found. +func FindRepoRoot(start string) (root string, ok bool) { + dir := start + for range 12 { + if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil { + return dir, true + } + parent := filepath.Dir(dir) + if parent == dir { + break + } + dir = parent + } + return "", false +} + +// topLevelEntries returns the set of names directly under the repo root. A +// candidate path is only treated as repo-relative when its first segment is one +// of these, which is what distinguishes examples\public\counter\main.go (real) +// from a user-project placeholder like .\main.go. +func topLevelEntries(root string) (map[string]bool, error) { + entries, err := os.ReadDir(root) + if err != nil { + return nil, err + } + set := make(map[string]bool, len(entries)) + for _, e := range entries { + set[e.Name()] = true + } + return set, nil +} + +// ScanRepo walks every tracked Markdown file under root and returns the +// repo-relative input path references found inside fenced command blocks whose +// first segment is a real top-level repo entry. +func ScanRepo(root string) ([]PathRef, error) { + topLevel, err := topLevelEntries(root) + if err != nil { + return nil, err + } + var refs []PathRef + walkErr := filepath.Walk(root, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + if dirsSkipped[info.Name()] { + return filepath.SkipDir + } + // Skip generated browser-compiler package archives anywhere. + if info.Name() == "pkg" && strings.Contains(filepath.ToSlash(path), "browser-compiler") { + return filepath.SkipDir + } + return nil + } + if strings.ToLower(filepath.Ext(path)) != ".md" { + return nil + } + rel, relErr := filepath.Rel(root, path) + if relErr != nil { + return relErr + } + relSlash := filepath.ToSlash(rel) + if strings.HasPrefix(relSlash, snapshotDocDir) { + return nil + } + fileRefs, scanErr := scanFile(path, relSlash, topLevel) + if scanErr != nil { + return scanErr + } + refs = append(refs, fileRefs...) + return nil + }) + if walkErr != nil { + return nil, walkErr + } + return refs, nil +} + +// scanFile extracts candidate path references from one Markdown file. +func scanFile(absPath, docRel string, topLevel map[string]bool) ([]PathRef, error) { + file, err := os.Open(absPath) + if err != nil { + return nil, err + } + defer file.Close() + + var refs []PathRef + scanner := bufio.NewScanner(file) + scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024) + inFence := false + blockIsShell := false + lineNo := 0 + for scanner.Scan() { + lineNo++ + line := scanner.Text() + if m := fenceOpen.FindStringSubmatch(line); m != nil { + if inFence { + inFence = false + blockIsShell = false + } else { + inFence = true + blockIsShell = shellLangs[strings.ToLower(m[1])] + } + continue + } + if !inFence { + continue + } + // Scan labeled shell blocks, and unlabeled blocks only on lines that + // clearly begin a command. This keeps prose and code samples out. + if !blockIsShell && !looksLikeCommand(line) { + continue + } + for _, ref := range candidatesInLine(line, topLevel) { + ref.DocPath = docRel + ref.Line = lineNo + refs = append(refs, ref) + } + } + if err := scanner.Err(); err != nil { + return nil, err + } + return refs, nil +} + +// candidatesInLine returns the repo-relative path references in a single command +// line, skipping output-flag arguments and placeholder stand-ins. +func candidatesInLine(line string, topLevel map[string]bool) []PathRef { + fields := strings.Fields(line) + var refs []PathRef + for i, field := range fields { + if i > 0 && outputFlags[strings.ToLower(fields[i-1])] { + continue + } + token := strings.Trim(field, "\"'`,;:()") + if !pathToken.MatchString(token) { + continue + } + if isPlaceholder(token) { + continue + } + rel := normalizeToken(token) + if rel == "" { + continue + } + first := rel + if before, _, ok := strings.Cut(rel, "/"); ok { + first = before + } + if !topLevel[first] { + continue + } + // Generated output trees are never expected to exist on a clean tree, + // at any depth (a project's bin/ or dist/ holds build and runtime + // artifacts: wasm, logs, sqlite files). + if strings.HasPrefix(rel, "bin/") || strings.Contains(rel, "/bin/") || + strings.Contains(rel, "/dist/") || strings.HasSuffix(rel, "/dist") { + continue + } + refs = append(refs, PathRef{Raw: token, Rel: rel}) + } + return refs +} + +// looksLikeCommand reports whether a line (inside an unlabeled fenced block) +// begins with a recognized command verb. +func looksLikeCommand(line string) bool { + trimmed := strings.ToLower(strings.TrimSpace(line)) + for _, verb := range commandVerbs { + if strings.HasPrefix(trimmed, verb) { + return true + } + } + return false +} + +// isPlaceholder reports whether a token is an illustrative stand-in path. +func isPlaceholder(token string) bool { + lower := strings.ToLower(filepath.ToSlash(token)) + for _, hint := range placeholderHints { + if strings.Contains(lower, strings.ToLower(filepath.ToSlash(hint))) { + return true + } + } + return false +} + +// normalizeToken converts a Windows or POSIX command token into a clean +// forward-slash repo-relative path, or "" if it is not a real path candidate. +func normalizeToken(token string) string { + clean := filepath.ToSlash(token) + clean = strings.TrimPrefix(clean, "./") + clean = strings.TrimPrefix(clean, ".\\") + clean = strings.TrimPrefix(clean, "/") + clean = strings.TrimSpace(clean) + // A bare token with no separators and no extension is not a path argument. + if !strings.Contains(clean, "/") { + return "" + } + return clean +} + +// Resolve reports the references whose target does not exist under root. A reference is +// considered live if it resolves EITHER repo-root-relative (the front-door case: README/getting- +// started commands run from the repo root) OR relative to its own doc file's directory (a subdir +// README whose command runs from that subdir, e.g. tools/devtools-extension/README.md running +// `node --test test/bridge.test.mjs` from the extension dir). Accepting the doc-dir-relative +// resolution removes a false-positive class without weakening the front-door drift guard. +func Resolve(root string, refs []PathRef) []PathRef { + var broken []PathRef + for _, ref := range refs { + if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(ref.Rel))); err == nil { + continue + } + if ref.DocPath != "" { + docDir := filepath.Dir(filepath.FromSlash(ref.DocPath)) + if _, err := os.Stat(filepath.Join(root, docDir, filepath.FromSlash(ref.Rel))); err == nil { + continue + } + } + broken = append(broken, ref) + } + return broken +} diff --git a/docs/doclint/doclint_test.go b/docs/doclint/doclint_test.go new file mode 100644 index 00000000..7e244755 --- /dev/null +++ b/docs/doclint/doclint_test.go @@ -0,0 +1,175 @@ +package doclint + +import ( + "fmt" + "os" + "path/filepath" + "sort" + "strings" + "testing" +) + +// repoRoot resolves the module root from the test working directory. +func repoRoot(t *testing.T) string { + t.Helper() + wd, err := os.Getwd() + if err != nil { + t.Fatalf("getwd: %v", err) + } + root, ok := FindRepoRoot(wd) + if !ok { + t.Fatalf("module root not found from %s", wd) + } + return root +} + +// TestDocsHaveNoBrokenGoSamples is the doc-sample drift guard (F1 "docs can't silently lie"): +// every complete-file ```go sample in the docs must parse, so a renamed API or a fat-fingered +// edit that leaves a copy-paste-runnable sample broken fails CI instead of shipping. Fragments +// (snippets without a package clause) are intentionally not checked, keeping zero false positives. +// Runs under `go test ./...`, which gates PRs. +func TestDocsHaveNoBrokenGoSamples(t *testing.T) { + root := repoRoot(t) + errs, err := ValidateGoBlocks(root) + if err != nil { + t.Fatalf("validate doc go samples: %v", err) + } + if len(errs) > 0 { + var b strings.Builder + for _, e := range errs { + fmt.Fprintf(&b, " %s:%d — %s\n", e.DocPath, e.Line, e.Err) + } + t.Fatalf("docs contain %d complete-file ```go sample(s) that no longer parse:\n%s", len(errs), b.String()) + } +} + +// TestGoSampleGuardCatchesBreakage proves the sample guard actually fails on a broken +// complete-file block (and ignores a fragment), so the zero-error baseline is meaningful. +func TestGoSampleGuardCatchesBreakage(t *testing.T) { + dir := t.TempDir() + if err := os.WriteFile(filepath.Join(dir, "broken.md"), + []byte("```go\npackage main\nfunc main( {\n```\n"), 0o644); err != nil { + t.Fatalf("write fixture: %v", err) + } + errs, err := ValidateGoBlocks(dir) + if err != nil { + t.Fatalf("validate: %v", err) + } + if len(errs) != 1 { + t.Fatalf("expected the planted broken sample to be caught, got %d", len(errs)) + } +} + +// TestDocsHaveNoBrokenRepoPaths is the drift guard: every repo-relative input +// path referenced in a fenced doc command must resolve on disk. This is the +// check that would have failed the build the moment examples/01-counter was +// relocated without updating the README/getting-started/AGENTS commands, and it +// stays at zero tolerance so any future rename that strands a doc command fails +// CI instead of shipping a broken front door. +func TestDocsHaveNoBrokenRepoPaths(t *testing.T) { + root := repoRoot(t) + refs, err := ScanRepo(root) + if err != nil { + t.Fatalf("scan repo docs: %v", err) + } + if len(refs) == 0 { + t.Fatal("guard found zero repo-relative doc paths to check; the scanner is likely misconfigured") + } + broken := Resolve(root, refs) + if len(broken) > 0 { + lines := make([]string, 0, len(broken)) + for _, b := range broken { + lines = append(lines, b.DocPath+":"+itoa(b.Line)+" -> "+b.Raw+" (resolved "+b.Rel+")") + } + sort.Strings(lines) + t.Fatalf("docs reference %d repo path(s) that no longer exist:\n%s\n\n"+ + "Fix each path to its current location (the example/dir was likely renamed or moved).", + len(broken), strings.Join(lines, "\n")) + } +} + +// TestGuardCatchesPlantedBreakage proves the guard itself works: a fixture doc +// with a known-dead repo path must be reported, and a fixture with a live path +// must not. Without this, a green guard could mean "nothing broken" or "scanner +// silently broke" and we could not tell them apart. +func TestGuardCatchesPlantedBreakage(t *testing.T) { + root := t.TempDir() + // Minimal fake repo: a go.mod and a real top-level dir the doc can point at. + mustWrite(t, filepath.Join(root, "go.mod"), "module example.com/fixture\n") + mustMkdir(t, filepath.Join(root, "examples", "public", "counter")) + mustWrite(t, filepath.Join(root, "examples", "public", "counter", "main.go"), "package main\n") + + dead := "# Doc\n\n```powershell\n" + + "go run ./tools/gwc dev -app .\\examples\\public\\counter\\main.go\n" + // live + "go run ./tools/gwc dev -app .\\examples\\01-counter\\main.go\n" + // dead + "go run ./tools/gwc build -app .\\main.go -out .\\bin\\x.wasm\n" + // placeholder + output, both skipped + "```\n" + mustWrite(t, filepath.Join(root, "README.md"), dead) + + refs, err := ScanRepo(root) + if err != nil { + t.Fatalf("scan fixture: %v", err) + } + broken := Resolve(root, refs) + if len(broken) != 1 { + t.Fatalf("expected exactly 1 broken ref, got %d: %+v", len(broken), broken) + } + if !strings.Contains(filepath.ToSlash(broken[0].Rel), "examples/01-counter") { + t.Fatalf("guard flagged the wrong path: %q", broken[0].Rel) + } + // The live path and the user-project placeholder/output must NOT be flagged. + for _, b := range broken { + if strings.Contains(b.Rel, "public/counter") { + t.Fatalf("guard wrongly flagged the live counter path: %q", b.Rel) + } + } +} + +// TestSnapshotDocsAreExempt confirms the archival example-site docs subtree is +// not scanned, so its preserved historical numbered paths do not fail the lane. +func TestSnapshotDocsAreExempt(t *testing.T) { + root := t.TempDir() + mustWrite(t, filepath.Join(root, "go.mod"), "module example.com/fixture\n") + mustMkdir(t, filepath.Join(root, "examples")) + snapDir := filepath.Join(root, filepath.FromSlash(snapshotDocDir)) + mustMkdir(t, snapDir) + mustWrite(t, filepath.Join(snapDir, "history.md"), + "```powershell\ngo run ./tools/gwc dev -app .\\examples\\01-counter\\main.go\n```\n") + + refs, err := ScanRepo(root) + if err != nil { + t.Fatalf("scan: %v", err) + } + if len(Resolve(root, refs)) != 0 { + t.Fatalf("snapshot docs should be exempt but a path was flagged: %+v", Resolve(root, refs)) + } +} + +func mustWrite(t *testing.T, path, content string) { + t.Helper() + if err := os.WriteFile(path, []byte(content), 0o644); err != nil { + t.Fatalf("write %s: %v", path, err) + } +} + +func mustMkdir(t *testing.T, path string) { + t.Helper() + if err := os.MkdirAll(path, 0o755); err != nil { + t.Fatalf("mkdir %s: %v", path, err) + } +} + +// itoa avoids importing strconv for one tiny conversion in the failure path. +func itoa(n int) string { + if n == 0 { + return "0" + } + var b [20]byte + i := len(b) + for n > 0 { + i-- + b[i] = byte('0' + n%10) + n /= 10 + } + return string(b[i:]) +} diff --git a/docs/doclint/flags.go b/docs/doclint/flags.go new file mode 100644 index 00000000..a04daa1a --- /dev/null +++ b/docs/doclint/flags.go @@ -0,0 +1,132 @@ +package doclint + +import ( + "os" + "path/filepath" + "regexp" + "strings" +) + +// FlagRef is one `-flag` token found on a gwc command line in a doc, which does +// not correspond to any flag defined in the gwc launcher source. +type FlagRef struct { + DocPath string + Line int + Flag string +} + +var ( + // gwcDir is the launcher source directory, relative to the repo root. + gwcDirRel = filepath.FromSlash("tools/gwc") + + // nameFirstFlagPattern matches flag definitions whose name is the first + // argument: parseFs.String("name", ...), .Bool(...), .Int(...), etc. + nameFirstFlagPattern = regexp.MustCompile(`\.(?:String|Bool|Int|Int64|Uint|Duration|Float64)\("([a-z][a-z0-9-]*)"`) + // varFlagPattern matches flag.Var(&value, "name", ...), where the flag name + // is the SECOND argument (repeatable/custom flags like -lane, -ext). + varFlagPattern = regexp.MustCompile(`\.Var\([^,]+,\s*"([a-z][a-z0-9-]*)"`) + // docFlagPattern matches a `-flag` token (not a value, not `--`). + docFlagPattern = regexp.MustCompile(`(^|\s)-([a-z][a-z0-9-]*)`) +) + +// builtinFlagAllowlist are flags every Go flag set understands implicitly. +var builtinFlagAllowlist = map[string]bool{"h": true, "help": true} + +// ExtractKnownGwcFlags returns the set of flag names defined anywhere in the +// gwc launcher source under gwcDir (handling both name-first definitions and +// flag.Var definitions where the name is the second argument). +func ExtractKnownGwcFlags(parseGwcDir string) (map[string]bool, error) { + parseKnown := map[string]bool{} + for parseName := range builtinFlagAllowlist { + parseKnown[parseName] = true + } + parseEntries, parseErr := os.ReadDir(parseGwcDir) + if parseErr != nil { + return nil, parseErr + } + for _, parseEntry := range parseEntries { + parseName := parseEntry.Name() + if parseEntry.IsDir() || !strings.HasSuffix(parseName, ".go") || strings.HasSuffix(parseName, "_test.go") { + continue + } + parseData, parseReadErr := os.ReadFile(filepath.Join(parseGwcDir, parseName)) + if parseReadErr != nil { + return nil, parseReadErr + } + parseSource := string(parseData) + for _, parseMatch := range nameFirstFlagPattern.FindAllStringSubmatch(parseSource, -1) { + parseKnown[parseMatch[1]] = true + } + for _, parseMatch := range varFlagPattern.FindAllStringSubmatch(parseSource, -1) { + parseKnown[parseMatch[1]] = true + } + } + return parseKnown, nil +} + +// ScanDocGwcFlags returns every `-flag` used on a gwc command line in a tracked +// Markdown shell block whose flag name is not in parseKnown. It is the +// flag-existence half (part c) of the doc-drift guard: a renamed or removed +// launcher flag still referenced in docs is reported. +func ScanDocGwcFlags(parseRoot string, parseKnown map[string]bool) ([]FlagRef, error) { + var parseRefs []FlagRef + parseErr := filepath.Walk(parseRoot, func(parsePath string, parseInfo os.FileInfo, parseWalkErr error) error { + if parseWalkErr != nil { + return parseWalkErr + } + if parseInfo.IsDir() { + if dirsSkipped[parseInfo.Name()] { + return filepath.SkipDir + } + return nil + } + if strings.ToLower(filepath.Ext(parsePath)) != ".md" { + return nil + } + parseRel, parseRelErr := filepath.Rel(parseRoot, parsePath) + if parseRelErr != nil { + return parseRelErr + } + parseRelSlash := filepath.ToSlash(parseRel) + if strings.HasPrefix(parseRelSlash, snapshotDocDir) { + return nil + } + parseData, parseReadErr := os.ReadFile(parsePath) + if parseReadErr != nil { + return parseReadErr + } + parseRefs = append(parseRefs, scanFileFlags(string(parseData), parseRelSlash, parseKnown)...) + return nil + }) + if parseErr != nil { + return nil, parseErr + } + return parseRefs, nil +} + +// scanFileFlags extracts unknown gwc flags from one Markdown file's shell blocks. +func scanFileFlags(parseContent string, parseDocRel string, parseKnown map[string]bool) []FlagRef { + var parseRefs []FlagRef + parseInFence := false + for parseIndex, parseLine := range strings.Split(parseContent, "\n") { + if fenceOpen.MatchString(parseLine) { + parseInFence = !parseInFence + continue + } + if !parseInFence { + continue + } + // Only inspect lines that actually invoke the gwc launcher, so flags for + // go/node/other tools on neighboring lines are not misread as gwc flags. + if !strings.Contains(parseLine, "gwc ") && !strings.Contains(parseLine, "tools/gwc") { + continue + } + for _, parseMatch := range docFlagPattern.FindAllStringSubmatch(parseLine, -1) { + parseFlag := parseMatch[2] + if !parseKnown[parseFlag] { + parseRefs = append(parseRefs, FlagRef{DocPath: parseDocRel, Line: parseIndex + 1, Flag: parseFlag}) + } + } + } + return parseRefs +} diff --git a/docs/doclint/flags_test.go b/docs/doclint/flags_test.go new file mode 100644 index 00000000..d979d602 --- /dev/null +++ b/docs/doclint/flags_test.go @@ -0,0 +1,73 @@ +package doclint + +import ( + "os" + "path/filepath" + "sort" + "strings" + "testing" +) + +// TestExtractKnownGwcFlagsFindsVarFlags pins that both definition styles are +// captured, including flag.Var flags (e.g. -lane, -ext) whose name is the +// second argument. +func TestExtractKnownGwcFlagsFindsVarFlags(t *testing.T) { + root := repoRoot(t) + known, err := ExtractKnownGwcFlags(filepath.Join(root, gwcDirRel)) + if err != nil { + t.Fatalf("extract known flags: %v", err) + } + for _, want := range []string{"app", "root", "profile", "lane", "ext", "exclude-dir", "compression"} { + if !known[want] { + t.Fatalf("expected known gwc flag %q to be extracted", want) + } + } +} + +// TestDocsGwcFlagsExist is the flag-existence guard: every -flag used on a gwc +// command line in the docs must correspond to a real launcher flag. A renamed +// or removed flag still cited in docs fails here. +func TestDocsGwcFlagsExist(t *testing.T) { + root := repoRoot(t) + known, err := ExtractKnownGwcFlags(filepath.Join(root, gwcDirRel)) + if err != nil { + t.Fatalf("extract known flags: %v", err) + } + unknown, err := ScanDocGwcFlags(root, known) + if err != nil { + t.Fatalf("scan doc flags: %v", err) + } + if len(unknown) > 0 { + lines := make([]string, 0, len(unknown)) + for _, u := range unknown { + lines = append(lines, u.DocPath+":"+itoa(u.Line)+" -> -"+u.Flag) + } + sort.Strings(lines) + t.Fatalf("docs reference %d gwc flag(s) that no longer exist:\n%s", len(unknown), strings.Join(lines, "\n")) + } +} + +// TestScanDocGwcFlagsCatchesPlantedUnknown proves the guard works: a fixture doc +// citing a removed flag is reported, while a real flag and a non-gwc tool's flag +// on another line are not. +func TestScanDocGwcFlagsCatchesPlantedUnknown(t *testing.T) { + root := t.TempDir() + doc := "# Doc\n\n```powershell\n" + + "go run ./tools/gwc dev -app .\\main.go -totallyfakeflag x\n" + // gwc line: app ok, totallyfakeflag bad + "go test ./... -count=1 -v\n" + // not a gwc line: -count/-v must be ignored + "```\n" + if err := os.WriteFile(filepath.Join(root, "README.md"), []byte(doc), 0o644); err != nil { + t.Fatalf("write fixture: %v", err) + } + known := map[string]bool{"app": true, "h": true} + unknown, err := ScanDocGwcFlags(root, known) + if err != nil { + t.Fatalf("scan: %v", err) + } + if len(unknown) != 1 { + t.Fatalf("expected exactly 1 unknown flag, got %d: %+v", len(unknown), unknown) + } + if unknown[0].Flag != "totallyfakeflag" { + t.Fatalf("guard flagged the wrong token: %q", unknown[0].Flag) + } +} diff --git a/docs/doclint/goblocks.go b/docs/doclint/goblocks.go new file mode 100644 index 00000000..8d5211bd --- /dev/null +++ b/docs/doclint/goblocks.go @@ -0,0 +1,224 @@ +package doclint + +import ( + "bufio" + "fmt" + "go/parser" + "go/token" + "os" + "os/exec" + "path/filepath" + "strings" +) + +// GoBlock is one fenced ```go code block in the docs that is a COMPLETE Go file (it declares a +// package). Fragments — snippets without a package clause — are intentionally not validated here, +// keeping the guard high-precision (zero false positives) like the path-reference scanner: only +// copy-paste-runnable samples are checked, which is exactly the rot that breaks a fresh reader. +type GoBlock struct { + DocPath string // repo-relative path of the Markdown file + Line int // 1-based line of the block's opening fence + Source string // the block's Go source + // Compile is true when the opening fence is marked `gwc:build` — an opt-in that the sample + // is a complete, runnable program to be type-checked (compiled), not just parsed. Native is + // true for the `gwc:build:native` variant (a server/native sample); otherwise the sample is + // compiled for the browser (js/wasm) target. + Compile bool + Native bool +} + +// GoBlockError is a complete-file ```go sample that no longer parses, so the docs would silently +// hand a reader broken Go. +type GoBlockError struct { + DocPath string + Line int + Err string +} + +// goFenceLangs are the fenced-block language hints whose contents are Go source. +var goFenceLangs = map[string]bool{"go": true, "golang": true} + +// ScanGoBlocks walks every tracked Markdown file under root and returns the complete-file ```go +// blocks (those containing a top-level `package ` declaration). +func ScanGoBlocks(root string) ([]GoBlock, error) { + var blocks []GoBlock + walkErr := filepath.Walk(root, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if info.IsDir() { + if dirsSkipped[info.Name()] { + return filepath.SkipDir + } + if info.Name() == "pkg" && strings.Contains(filepath.ToSlash(path), "browser-compiler") { + return filepath.SkipDir + } + return nil + } + if strings.ToLower(filepath.Ext(path)) != ".md" { + return nil + } + rel, relErr := filepath.Rel(root, path) + if relErr != nil { + return relErr + } + relSlash := filepath.ToSlash(rel) + if strings.HasPrefix(relSlash, snapshotDocDir) { + return nil + } + fileBlocks, scanErr := scanGoBlocksInFile(path, relSlash) + if scanErr != nil { + return scanErr + } + blocks = append(blocks, fileBlocks...) + return nil + }) + if walkErr != nil { + return nil, walkErr + } + return blocks, nil +} + +// scanGoBlocksInFile extracts the complete-file ```go blocks from one Markdown file. +func scanGoBlocksInFile(absPath, docRel string) ([]GoBlock, error) { + file, err := os.Open(absPath) + if err != nil { + return nil, err + } + defer file.Close() + + var blocks []GoBlock + scanner := bufio.NewScanner(file) + scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024) + lineNo := 0 + inGo := false + fenceLine := 0 + fenceCompile := false + fenceNative := false + var current strings.Builder + for scanner.Scan() { + lineNo++ + line := scanner.Text() + if m := fenceOpen.FindStringSubmatch(line); m != nil { + if inGo { + // Closing fence: keep only complete-file blocks (those with a package clause). + source := current.String() + if goBlockIsCompleteFile(source) { + blocks = append(blocks, GoBlock{DocPath: docRel, Line: fenceLine, Source: source, Compile: fenceCompile, Native: fenceNative}) + } + inGo = false + current.Reset() + continue + } + if goFenceLangs[strings.ToLower(m[1])] { + inGo = true + fenceLine = lineNo + fenceCompile = strings.Contains(line, "gwc:build") + fenceNative = strings.Contains(line, "gwc:build:native") + current.Reset() + } + continue + } + if inGo { + current.WriteString(line) + current.WriteByte('\n') + } + } + if err := scanner.Err(); err != nil { + return nil, err + } + return blocks, nil +} + +// goBlockIsCompleteFile reports whether a ```go block is a full Go file (has a top-level +// `package` declaration), as opposed to a fragment. Only complete files are validated. +func goBlockIsCompleteFile(source string) bool { + for raw := range strings.SplitSeq(source, "\n") { + trimmed := strings.TrimSpace(raw) + if strings.HasPrefix(trimmed, "package ") { + return true + } + } + return false +} + +// GoBlockCompileError is a `gwc:build`-marked sample that failed to compile (type-check) against +// the real module — the type-level "docs can't silently lie" guard (a renamed/removed API used +// by a runnable sample fails here even though it still parses). +type GoBlockCompileError struct { + DocPath string + Line int + Err string +} + +// CompileMarkedGoBlocks compiles every `gwc:build`-marked complete-file sample against the real +// module: each is written to a throwaway module with a `replace` to repoRoot and built with +// `go build` (js/wasm by default, native for `gwc:build:native`). This is the opt-in type-level +// gate — only samples explicitly marked as runnable programs are compiled, so illustrative +// fragments never produce false failures. repoRoot is the module root (contains go.mod). +func CompileMarkedGoBlocks(repoRoot string) ([]GoBlockCompileError, error) { + blocks, err := ScanGoBlocks(repoRoot) + if err != nil { + return nil, err + } + var errs []GoBlockCompileError + for index, block := range blocks { + if !block.Compile { + continue + } + if buildErr := compileSampleInModule(repoRoot, block, index); buildErr != "" { + errs = append(errs, GoBlockCompileError{DocPath: block.DocPath, Line: block.Line, Err: buildErr}) + } + } + return errs, nil +} + +// compileSampleInModule writes one sample to a temp module (replace → repoRoot) and `go build`s +// it, returning "" on success or the combined build output on failure. +func compileSampleInModule(repoRoot string, block GoBlock, index int) string { + tempDir, err := os.MkdirTemp("", fmt.Sprintf("gwc-docsample-%d-", index)) + if err != nil { + return "mktemp: " + err.Error() + } + defer os.RemoveAll(tempDir) + + if err := os.WriteFile(filepath.Join(tempDir, "main.go"), []byte(block.Source), 0o644); err != nil { + return "write sample: " + err.Error() + } + goMod := "module gwcdocsample\n\ngo 1.26\n\nrequire github.com/monstercameron/GoWebComponents v0.0.0\n" + + "replace github.com/monstercameron/GoWebComponents => " + filepath.ToSlash(repoRoot) + "\n" + if err := os.WriteFile(filepath.Join(tempDir, "go.mod"), []byte(goMod), 0o644); err != nil { + return "write go.mod: " + err.Error() + } + + cmd := exec.Command("go", "build", "./...") + cmd.Dir = tempDir + env := append(os.Environ(), "GOFLAGS=-mod=mod") + if !block.Native { + env = append(env, "GOOS=js", "GOARCH=wasm") + } + cmd.Env = env + if out, err := cmd.CombinedOutput(); err != nil { + return strings.TrimSpace(string(out)) + } + return "" +} + +// ValidateGoBlocks parses every complete-file ```go sample under root and returns the ones that +// no longer parse — the documentation-can't-silently-lie guard for code samples. It uses +// go/parser (offline, deterministic, no module resolution) so the lane stays fast and +// dependency-free, matching the path-reference guard's design. +func ValidateGoBlocks(root string) ([]GoBlockError, error) { + blocks, err := ScanGoBlocks(root) + if err != nil { + return nil, err + } + var errs []GoBlockError + for _, block := range blocks { + fset := token.NewFileSet() + if _, parseErr := parser.ParseFile(fset, "sample.go", block.Source, parser.AllErrors); parseErr != nil { + errs = append(errs, GoBlockError{DocPath: block.DocPath, Line: block.Line, Err: parseErr.Error()}) + } + } + return errs, nil +} diff --git a/docs/doclint/goblocks_compile_test.go b/docs/doclint/goblocks_compile_test.go new file mode 100644 index 00000000..6fef613b --- /dev/null +++ b/docs/doclint/goblocks_compile_test.go @@ -0,0 +1,50 @@ +//go:build doccompile + +package doclint + +import ( + "os" + "testing" +) + +// TestDocsMarkedSamplesCompile is the F1 type-level gate: every `gwc:build`-marked complete-file +// doc sample must COMPILE against the real module (not just parse), so a renamed/removed API used +// by a runnable sample fails CI even though the sample is still syntactically valid Go. Behind +// the `doccompile` build tag because it shells out to `go build` per sample; the dedicated +// doc-samples.yml workflow runs it. There must be at least one marked sample so the gate is real. +func TestDocsMarkedSamplesCompile(t *testing.T) { + wd, err := os.Getwd() + if err != nil { + t.Fatalf("getwd: %v", err) + } + root, ok := FindRepoRoot(wd) + if !ok { + t.Fatalf("module root not found") + } + + blocks, err := ScanGoBlocks(root) + if err != nil { + t.Fatalf("scan go blocks: %v", err) + } + marked := 0 + for _, b := range blocks { + if b.Compile { + marked++ + } + } + if marked == 0 { + t.Fatal("no gwc:build-marked doc samples found; the compile gate would be a no-op (mark canonical runnable samples)") + } + + errs, err := CompileMarkedGoBlocks(root) + if err != nil { + t.Fatalf("compile marked samples: %v", err) + } + if len(errs) > 0 { + for _, e := range errs { + t.Errorf("%s:%d sample failed to compile:\n%s", e.DocPath, e.Line, e.Err) + } + t.Fatalf("%d gwc:build-marked doc sample(s) no longer compile", len(errs)) + } + t.Logf("compiled %d gwc:build-marked doc sample(s) clean", marked) +} diff --git a/docs/doclint/goblocks_test.go b/docs/doclint/goblocks_test.go new file mode 100644 index 00000000..7903c8c3 --- /dev/null +++ b/docs/doclint/goblocks_test.go @@ -0,0 +1,61 @@ +package doclint + +import ( + "os" + "path/filepath" + "testing" +) + +// TestValidateGoBlocks proves the doc-sample guard: a complete-file ```go sample that parses is +// accepted, a broken one is reported, and a fragment (no package clause) is skipped (high +// precision — only copy-paste-runnable samples are checked). +func TestValidateGoBlocks(parseT *testing.T) { + parseRoot := parseT.TempDir() + + parseGood := "# Good\n\n```go\npackage main\n\nfunc main() { _ = 1 }\n```\n" + parseBad := "# Bad\n\n```go\npackage main\n\nfunc main( {\n```\n" + parseFragment := "# Fragment\n\n```go\ncount := ui.UseState(0)\n```\n" + + mustWriteDoc(parseT, parseRoot, "good.md", parseGood) + mustWriteDoc(parseT, parseRoot, "fragment.md", parseFragment) + + // With only good + fragment docs, there must be zero errors (fragment is not validated). + parseErrs, parseErr := ValidateGoBlocks(parseRoot) + if parseErr != nil { + parseT.Fatalf("ValidateGoBlocks: %v", parseErr) + } + if len(parseErrs) != 0 { + parseT.Fatalf("expected no errors for good+fragment docs, got %+v", parseErrs) + } + + // Adding a broken complete-file sample must be reported. + mustWriteDoc(parseT, parseRoot, "bad.md", parseBad) + parseErrs, parseErr = ValidateGoBlocks(parseRoot) + if parseErr != nil { + parseT.Fatalf("ValidateGoBlocks: %v", parseErr) + } + if len(parseErrs) != 1 || parseErrs[0].DocPath != "bad.md" { + parseT.Fatalf("expected one error in bad.md, got %+v", parseErrs) + } +} + +// TestScanGoBlocksSkipsFragments proves only complete-file blocks are collected. +func TestScanGoBlocksSkipsFragments(parseT *testing.T) { + parseRoot := parseT.TempDir() + mustWriteDoc(parseT, parseRoot, "mix.md", + "```go\npackage app\n\nvar X = 1\n```\n\n```go\nX := 1\n_ = X\n```\n") + parseBlocks, parseErr := ScanGoBlocks(parseRoot) + if parseErr != nil { + parseT.Fatalf("ScanGoBlocks: %v", parseErr) + } + if len(parseBlocks) != 1 { + parseT.Fatalf("expected 1 complete-file block (fragment skipped), got %d", len(parseBlocks)) + } +} + +func mustWriteDoc(parseT *testing.T, parseDir, parseName, parseContent string) { + parseT.Helper() + if parseErr := os.WriteFile(filepath.Join(parseDir, parseName), []byte(parseContent), 0o644); parseErr != nil { + parseT.Fatalf("write %s: %v", parseName, parseErr) + } +} diff --git a/docs/errorcodes/errorcodes.go b/docs/errorcodes/errorcodes.go new file mode 100644 index 00000000..491d3d94 --- /dev/null +++ b/docs/errorcodes/errorcodes.go @@ -0,0 +1,171 @@ +// Package errorcodes extracts the framework's diagnostic codes from the runtime +// source of truth and renders the generated error-code reference page. The page +// is never hand-maintained: TestErrorCodeReferenceIsGenerated regenerates it +// from internal/runtime/diagnostic_metadata.go and fails if the committed page +// drifts, so every code a developer (or agent) can see in a report is always +// looked-up-able with its cause anchor and remediation. +package errorcodes + +import ( + "regexp" + "sort" + "strings" +) + +// ErrorCode is one diagnostic code with its docs anchor and remediation text. +type ErrorCode struct { + Code string + Docs string + Remediation string +} + +const actionableErrorsDoc = "ACTIONABLE_ERRORS.md" + +var ( + codeAssignPattern = regexp.MustCompile(`\.Code\s*=\s*"([A-Z0-9-]+)"`) + docsAssignPattern = regexp.MustCompile(`\.Docs\s*=\s*(.+)$`) + remedAssignPattern = regexp.MustCompile(`\.Remediation\s*=\s*"(.*)"\s*$`) + caseCodePattern = regexp.MustCompile(`return\s+"([A-Z0-9-]+)"`) + caseDocsPattern = regexp.MustCompile(`return\s+(.+)$`) + quotedPattern = regexp.MustCompile(`"([^"]*)"`) +) + +// ExtractCodes parses the diagnostic-metadata source and returns every code, +// sorted by code, deduplicated (the descriptive switch wins over the +// phase-keyed panic helpers, which only add codes the switch omits). +func ExtractCodes(parseSource string) []ErrorCode { + parseSource = strings.ReplaceAll(parseSource, "\r\n", "\n") + parseSource = strings.ReplaceAll(parseSource, "\r", "") + + parseByCode := map[string]ErrorCode{} + + // Primary source: the diagnosticMetadata switch, which sets .Code, .Docs, + // and .Remediation in that order per case. + var parsePending ErrorCode + for parseLine := range strings.SplitSeq(parseSource, "\n") { + if parseMatch := codeAssignPattern.FindStringSubmatch(parseLine); parseMatch != nil { + parsePending = ErrorCode{Code: parseMatch[1]} + continue + } + if parseMatch := docsAssignPattern.FindStringSubmatch(parseLine); parseMatch != nil && parsePending.Code != "" { + parsePending.Docs = resolveDocsExpression(parseMatch[1]) + continue + } + if parseMatch := remedAssignPattern.FindStringSubmatch(parseLine); parseMatch != nil && parsePending.Code != "" { + parsePending.Remediation = parseMatch[1] + if _, parseExists := parseByCode[parsePending.Code]; !parseExists { + parseByCode[parsePending.Code] = parsePending + } + parsePending = ErrorCode{} + } + } + + // Secondary source: panic-phase helpers. panicDiagnosticCode maps phase -> + // code, panicDiagnosticDocs maps phase -> docs, panicDiagnosticRemediation + // maps phase -> remediation. They are keyed by the same `case :` + // labels, so align them positionally per function to recover codes (notably + // GWC-RUNTIME-PANIC-ASYNC) that have no descriptive switch entry. + parsePhaseCodes := extractFunctionReturns(parseSource, "func panicDiagnosticCode", caseCodePattern, false) + parsePhaseDocs := extractFunctionReturns(parseSource, "func panicDiagnosticDocs", caseDocsPattern, true) + parsePhaseRems := extractFunctionReturns(parseSource, "func panicDiagnosticRemediation", caseDocsPattern, true) + for parsePhase, parseCode := range parsePhaseCodes { + if parseCode == "" || strings.EqualFold(parseCode, "GWC-RUNTIME-PANIC") { + continue // skip the generic fallback + } + if _, parseExists := parseByCode[parseCode]; parseExists { + continue + } + parseByCode[parseCode] = ErrorCode{ + Code: parseCode, + Docs: resolveDocsExpression(parsePhaseDocs[parsePhase]), + Remediation: cleanRemediation(parsePhaseRems[parsePhase]), + } + } + + parseCodes := make([]ErrorCode, 0, len(parseByCode)) + for _, parseCode := range parseByCode { + parseCodes = append(parseCodes, parseCode) + } + sort.Slice(parseCodes, func(parseA, parseB int) bool { + return parseCodes[parseA].Code < parseCodes[parseB].Code + }) + return parseCodes +} + +// extractFunctionReturns scans a named func body's `case